(function (f) {
  if (typeof exports === "object" && typeof module !== "undefined") {
    module.exports = f()
  } else if (typeof define === "function" && define.amd) {
    define([], f)
  } else {
    var g;
    if (typeof window !== "undefined") {
      g = window
    } else if (typeof global !== "undefined") {
      g = global
    } else if (typeof self !== "undefined") {
      g = self
    } else {
      g = this
    }
    g.acorn = f()
  }
})(function () {
  var define, module, exports;
  return (function e(t, n, r) {
    function s(o, u) {
      if (!n[o]) {
        if (!t[o]) {
          var a = typeof require == "function" && require;
          if (!u && a) return a(o, !0);
          if (i) return i(o, !0);
          var f = new Error("Cannot find module '" + o + "'");
          throw f.code = "MODULE_NOT_FOUND", f
        }
        var l = n[o] = {exports: {}};
        t[o][0].call(l.exports, function (e) {
          var n = t[o][1][e];
          return s(n ? n : e)
        }, l, l.exports, e, t, n, r)
      }
      return n[o].exports
    }

    var i = typeof require == "function" && require;
    for (var o = 0; o < r.length; o++) s(r[o]);
    return s
  })({
    1: [function (require, module, exports) {


// The main exported interface (under `self.acorn` when in the
// browser) is a `parse` function that takes a code string and
// returns an abstract syntax tree as specified by [Mozilla parser
// API][api].
//
// [api]: https://developer.mozilla.org/en-US/docs/SpiderMonkey/Parser_API

      "use strict";

      exports.parse = parse;

// This function tries to parse a single expression at a given
// offset in a string. Useful for parsing mixed-language formats
// that embed JavaScript expressions.

      exports.parseExpressionAt = parseExpressionAt;

// Acorn is organized as a tokenizer and a recursive-descent parser.
// The `tokenize` export provides an interface to the tokenizer.

      exports.tokenizer = tokenizer;
      Object.defineProperty(exports, "__esModule", {
        value: true
      });
// Acorn is a tiny, fast JavaScript parser written in JavaScript.
//
// Acorn was written by Marijn Haverbeke, Ingvar Stepanyan, and
// various contributors and released under an MIT license.
//
// Git repositories for Acorn are available at
//
//     http://marijnhaverbeke.nl/git/acorn
//     https://github.com/marijnh/acorn.git
//
// Please use the [github bug tracker][ghbt] to report issues.
//
// [ghbt]: https://github.com/marijnh/acorn/issues
//
// This file defines the main parser interface. The library also comes
// with a [error-tolerant parser][dammit] and an
// [abstract syntax tree walker][walk], defined in other files.
//
// [dammit]: acorn_loose.js
// [walk]: util/walk.js

      var _state = require("./state");

      var Parser = _state.Parser;

      var _options = require("./options");

      var getOptions = _options.getOptions;

      require("./parseutil");

      require("./statement");

      require("./lval");

      require("./expression");

      exports.Parser = _state.Parser;
      exports.plugins = _state.plugins;
      exports.defaultOptions = _options.defaultOptions;

      var _location = require("./location");

      exports.SourceLocation = _location.SourceLocation;
      exports.getLineInfo = _location.getLineInfo;
      exports.Node = require("./node").Node;

      var _tokentype = require("./tokentype");

      exports.TokenType = _tokentype.TokenType;
      exports.tokTypes = _tokentype.types;

      var _tokencontext = require("./tokencontext");

      exports.TokContext = _tokencontext.TokContext;
      exports.tokContexts = _tokencontext.types;

      var _identifier = require("./identifier");

      exports.isIdentifierChar = _identifier.isIdentifierChar;
      exports.isIdentifierStart = _identifier.isIdentifierStart;
      exports.Token = require("./tokenize").Token;

      var _whitespace = require("./whitespace");

      exports.isNewLine = _whitespace.isNewLine;
      exports.lineBreak = _whitespace.lineBreak;
      exports.lineBreakG = _whitespace.lineBreakG;
      var version = "1.0.1";
      exports.version = version;

      function parse(input, options) {
        var p = parser(options, input);
        var startPos = p.options.locations ? [p.pos, p.curPosition()] : p.pos;
        p.nextToken();
        return p.parseTopLevel(p.options.program || p.startNodeAt(startPos));
      }

      function parseExpressionAt(input, pos, options) {
        var p = parser(options, input, pos);
        p.nextToken();
        return p.parseExpression();
      }

      function tokenizer(input, options) {
        return parser(options, input);
      }

      function parser(options, input) {
        return new Parser(getOptions(options), String(input));
      }

    }, {
      "./expression": 2,
      "./identifier": 3,
      "./location": 4,
      "./lval": 5,
      "./node": 6,
      "./options": 7,
      "./parseutil": 8,
      "./state": 9,
      "./statement": 10,
      "./tokencontext": 11,
      "./tokenize": 12,
      "./tokentype": 13,
      "./whitespace": 15
    }], 2: [function (require, module, exports) {
// A recursive descent parser operates by defining functions for all
// syntactic elements, and recursively calling those, each function
// advancing the input stream and returning an AST node. Precedence
// of constructs (for example, the fact that `!x[1]` means `!(x[1])`
// instead of `(!x)[1]` is handled by the fact that the parser
// function that parses unary prefix operators is called first, and
// in turn calls the function that parses `[]` subscripts — that
// way, it'll receive the node for `x[1]` already parsed, and wraps
// *that* in the unary operator node.
//
// Acorn uses an [operator precedence parser][opp] to handle binary
// operator precedence, because it is much more compact than using
// the technique outlined above, which uses different, nesting
// functions to specify precedence, for all of the ten binary
// precedence levels that JavaScript defines.
//
// [opp]: http://en.wikipedia.org/wiki/Operator-precedence_parser

      "use strict";

      var tt = require("./tokentype").types;

      var Parser = require("./state").Parser;

      var reservedWords = require("./identifier").reservedWords;

      var has = require("./util").has;

      var pp = Parser.prototype;

// Check if property name clashes with already added.
// Object/class getters and setters are not allowed to clash —
// either with each other or with an init property — and in
// strict mode, init properties are also not allowed to be repeated.

      pp.checkPropClash = function (prop, propHash) {
        if (this.options.ecmaVersion >= 6) return;
        var key = prop.key,
          name = undefined;
        switch (key.type) {
          case "Identifier":
            name = key.name;
            break;
          case "Literal":
            name = String(key.value);
            break;
          default:
            return;
        }
        var kind = prop.kind || "init",
          other = undefined;
        if (has(propHash, name)) {
          other = propHash[name];
          var isGetSet = kind !== "init";
          if ((this.strict || isGetSet) && other[kind] || !(isGetSet ^ other.init)) this.raise(key.start, "Redefinition of property");
        } else {
          other = propHash[name] = {
            init: false,
            get: false,
            set: false
          };
        }
        other[kind] = true;
      };

// ### Expression parsing

// These nest, from the most general expression type at the top to
// 'atomic', nondivisible expression types at the bottom. Most of
// the functions will simply let the function(s) below them parse,
// and, *if* the syntactic construct they handle is present, wrap
// the AST node that the inner parser gave them in another node.

// Parse a full expression. The optional arguments are used to
// forbid the `in` operator (in for loops initalization expressions)
// and provide reference for storing '=' operator inside shorthand
// property assignment in contexts where both object expression
// and object pattern might appear (so it's possible to raise
// delayed syntax error at correct position).

      pp.parseExpression = function (noIn, refShorthandDefaultPos) {
        var start = this.markPosition();
        var expr = this.parseMaybeAssign(noIn, refShorthandDefaultPos);
        if (this.type === tt.comma) {
          var node = this.startNodeAt(start);
          node.expressions = [expr];
          while (this.eat(tt.comma)) node.expressions.push(this.parseMaybeAssign(noIn, refShorthandDefaultPos));
          return this.finishNode(node, "SequenceExpression");
        }
        return expr;
      };

// Parse an assignment expression. This includes applications of
// operators like `+=`.

      pp.parseMaybeAssign = function (noIn, refShorthandDefaultPos) {
        if (this.type == tt._yield && this.inGenerator) return this.parseYield();

        var failOnShorthandAssign = undefined;
        if (!refShorthandDefaultPos) {
          refShorthandDefaultPos = {start: 0};
          failOnShorthandAssign = true;
        } else {
          failOnShorthandAssign = false;
        }
        var start = this.markPosition();
        var left = this.parseMaybeConditional(noIn, refShorthandDefaultPos);
        if (this.type.isAssign) {
          var node = this.startNodeAt(start);
          node.operator = this.value;
          node.left = this.type === tt.eq ? this.toAssignable(left) : left;
          refShorthandDefaultPos.start = 0; // reset because shorthand default was used correctly
          this.checkLVal(left);
          this.next();
          node.right = this.parseMaybeAssign(noIn);
          return this.finishNode(node, "AssignmentExpression");
        } else if (failOnShorthandAssign && refShorthandDefaultPos.start) {
          this.unexpected(refShorthandDefaultPos.start);
        }
        return left;
      };

// Parse a ternary conditional (`?:`) operator.

      pp.parseMaybeConditional = function (noIn, refShorthandDefaultPos) {
        var start = this.markPosition();
        var expr = this.parseExprOps(noIn, refShorthandDefaultPos);
        if (refShorthandDefaultPos && refShorthandDefaultPos.start) return expr;
        if (this.eat(tt.question)) {
          var node = this.startNodeAt(start);
          node.test = expr;
          node.consequent = this.parseMaybeAssign();
          this.expect(tt.colon);
          node.alternate = this.parseMaybeAssign(noIn);
          return this.finishNode(node, "ConditionalExpression");
        }
        return expr;
      };

// Start the precedence parser.

      pp.parseExprOps = function (noIn, refShorthandDefaultPos) {
        var start = this.markPosition();
        var expr = this.parseMaybeUnary(refShorthandDefaultPos);
        if (refShorthandDefaultPos && refShorthandDefaultPos.start) return expr;
        return this.parseExprOp(expr, start, -1, noIn);
      };

// Parse binary operators with the operator precedence parsing
// algorithm. `left` is the left-hand side of the operator.
// `minPrec` provides context that allows the function to stop and
// defer further parser to one of its callers when it encounters an
// operator that has a lower precedence than the set it is parsing.

      pp.parseExprOp = function (left, leftStart, minPrec, noIn) {
        var prec = this.type.binop;
        if (prec != null && (!noIn || this.type !== tt._in)) {
          if (prec > minPrec) {
            var node = this.startNodeAt(leftStart);
            node.left = left;
            node.operator = this.value;
            var op = this.type;
            this.next();
            var start = this.markPosition();
            node.right = this.parseExprOp(this.parseMaybeUnary(), start, prec, noIn);
            this.finishNode(node, op === tt.logicalOR || op === tt.logicalAND ? "LogicalExpression" : "BinaryExpression");
            return this.parseExprOp(node, leftStart, minPrec, noIn);
          }
        }
        return left;
      };

// Parse unary operators, both prefix and postfix.

      pp.parseMaybeUnary = function (refShorthandDefaultPos) {
        if (this.type.prefix) {
          var node = this.startNode(),
            update = this.type === tt.incDec;
          node.operator = this.value;
          node.prefix = true;
          this.next();
          node.argument = this.parseMaybeUnary();
          if (refShorthandDefaultPos && refShorthandDefaultPos.start) this.unexpected(refShorthandDefaultPos.start);
          if (update) this.checkLVal(node.argument); else if (this.strict && node.operator === "delete" && node.argument.type === "Identifier") this.raise(node.start, "Deleting local variable in strict mode");
          return this.finishNode(node, update ? "UpdateExpression" : "UnaryExpression");
        }
        var start = this.markPosition();
        var expr = this.parseExprSubscripts(refShorthandDefaultPos);
        if (refShorthandDefaultPos && refShorthandDefaultPos.start) return expr;
        while (this.type.postfix && !this.canInsertSemicolon()) {
          var node = this.startNodeAt(start);
          node.operator = this.value;
          node.prefix = false;
          node.argument = expr;
          this.checkLVal(expr);
          this.next();
          expr = this.finishNode(node, "UpdateExpression");
        }
        return expr;
      };

// Parse call, dot, and `[]`-subscript expressions.

      pp.parseExprSubscripts = function (refShorthandDefaultPos) {
        var start = this.markPosition();
        var expr = this.parseExprAtom(refShorthandDefaultPos);
        if (refShorthandDefaultPos && refShorthandDefaultPos.start) return expr;
        return this.parseSubscripts(expr, start);
      };

      pp.parseSubscripts = function (base, start, noCalls) {
        if (this.eat(tt.dot)) {
          var node = this.startNodeAt(start);
          node.object = base;
          node.property = this.parseIdent(true);
          node.computed = false;
          return this.parseSubscripts(this.finishNode(node, "MemberExpression"), start, noCalls);
        } else if (this.eat(tt.bracketL)) {
          var node = this.startNodeAt(start);
          node.object = base;
          node.property = this.parseExpression();
          node.computed = true;
          this.expect(tt.bracketR);
          return this.parseSubscripts(this.finishNode(node, "MemberExpression"), start, noCalls);
        } else if (!noCalls && this.eat(tt.parenL)) {
          var node = this.startNodeAt(start);
          node.callee = base;
          node.arguments = this.parseExprList(tt.parenR, false);
          return this.parseSubscripts(this.finishNode(node, "CallExpression"), start, noCalls);
        } else if (this.type === tt.backQuote) {
          var node = this.startNodeAt(start);
          node.tag = base;
          node.quasi = this.parseTemplate();
          return this.parseSubscripts(this.finishNode(node, "TaggedTemplateExpression"), start, noCalls);
        }
        return base;
      };

// Parse an atomic expression — either a single token that is an
// expression, an expression started by a keyword like `function` or
// `new`, or an expression wrapped in punctuation like `()`, `[]`,
// or `{}`.

      pp.parseExprAtom = function (refShorthandDefaultPos) {
        var node = undefined;
        switch (this.type) {
          case tt._this:
          case tt._super:
            var type = this.type === tt._this ? "ThisExpression" : "Super";
            node = this.startNode();
            this.next();
            return this.finishNode(node, type);

          case tt._yield:
            if (this.inGenerator) unexpected();

          case tt.name:
            var start = this.markPosition();
            var id = this.parseIdent(this.type !== tt.name);
            if (!this.canInsertSemicolon() && this.eat(tt.arrow)) {
              return this.parseArrowExpression(this.startNodeAt(start), [id]);
            }
            return id;

          case tt.regexp:
            var value = this.value;
            node = this.parseLiteral(value.value);
            node.regex = {pattern: value.pattern, flags: value.flags};
            return node;

          case tt.num:
          case tt.string:
            return this.parseLiteral(this.value);

          case tt._null:
          case tt._true:
          case tt._false:
            node = this.startNode();
            node.value = this.type === tt._null ? null : this.type === tt._true;
            node.raw = this.type.keyword;
            this.next();
            return this.finishNode(node, "Literal");

          case tt.parenL:
            return this.parseParenAndDistinguishExpression();

          case tt.bracketL:
            node = this.startNode();
            this.next();
            // check whether this is array comprehension or regular array
            if (this.options.ecmaVersion >= 7 && this.type === tt._for) {
              return this.parseComprehension(node, false);
            }
            node.elements = this.parseExprList(tt.bracketR, true, true, refShorthandDefaultPos);
            return this.finishNode(node, "ArrayExpression");

          case tt.braceL:
            return this.parseObj(false, refShorthandDefaultPos);

          case tt._function:
            node = this.startNode();
            this.next();
            return this.parseFunction(node, false);

          case tt._class:
            return this.parseClass(this.startNode(), false);

          case tt._new:
            return this.parseNew();

          case tt.backQuote:
            return this.parseTemplate();

          default:
            this.unexpected();
        }
      };

      pp.parseLiteral = function (value) {
        var node = this.startNode();
        node.value = value;
        node.raw = this.input.slice(this.start, this.end);
        this.next();
        return this.finishNode(node, "Literal");
      };

      pp.parseParenExpression = function () {
        this.expect(tt.parenL);
        var val = this.parseExpression();
        this.expect(tt.parenR);
        return val;
      };

      pp.parseParenAndDistinguishExpression = function () {
        var start = this.markPosition(),
          val = undefined;
        if (this.options.ecmaVersion >= 6) {
          this.next();

          if (this.options.ecmaVersion >= 7 && this.type === tt._for) {
            return this.parseComprehension(this.startNodeAt(start), true);
          }

          var innerStart = this.markPosition(),
            exprList = [],
            first = true;
          var refShorthandDefaultPos = {start: 0},
            spreadStart = undefined,
            innerParenStart = undefined;
          while (this.type !== tt.parenR) {
            first ? first = false : this.expect(tt.comma);
            if (this.type === tt.ellipsis) {
              spreadStart = this.start;
              exprList.push(this.parseRest());
              break;
            } else {
              if (this.type === tt.parenL && !innerParenStart) {
                innerParenStart = this.start;
              }
              exprList.push(this.parseMaybeAssign(false, refShorthandDefaultPos));
            }
          }
          var innerEnd = this.markPosition();
          this.expect(tt.parenR);

          if (!this.canInsertSemicolon() && this.eat(tt.arrow)) {
            if (innerParenStart) this.unexpected(innerParenStart);
            return this.parseArrowExpression(this.startNodeAt(start), exprList);
          }

          if (!exprList.length) this.unexpected(this.lastTokStart);
          if (spreadStart) this.unexpected(spreadStart);
          if (refShorthandDefaultPos.start) this.unexpected(refShorthandDefaultPos.start);

          if (exprList.length > 1) {
            val = this.startNodeAt(innerStart);
            val.expressions = exprList;
            this.finishNodeAt(val, "SequenceExpression", innerEnd);
          } else {
            val = exprList[0];
          }
        } else {
          val = this.parseParenExpression();
        }

        if (this.options.preserveParens) {
          var par = this.startNodeAt(start);
          par.expression = val;
          return this.finishNode(par, "ParenthesizedExpression");
        } else {
          return val;
        }
      };

// New's precedence is slightly tricky. It must allow its argument
// to be a `[]` or dot subscript expression, but not a call — at
// least, not without wrapping it in parentheses. Thus, it uses the

      var empty = [];

      pp.parseNew = function () {
        var node = this.startNode();
        var meta = this.parseIdent(true);
        if (this.options.ecmaVersion >= 6 && this.eat(tt.dot)) {
          node.meta = meta;
          node.property = this.parseIdent(true);
          if (node.property.name !== "target") this.raise(node.property.start, "The only valid meta property for new is new.target");
          return this.finishNode(node, "MetaProperty");
        }
        var start = this.markPosition();
        node.callee = this.parseSubscripts(this.parseExprAtom(), start, true);
        if (this.eat(tt.parenL)) node.arguments = this.parseExprList(tt.parenR, false); else node.arguments = empty;
        return this.finishNode(node, "NewExpression");
      };

// Parse template expression.

      pp.parseTemplateElement = function () {
        var elem = this.startNode();
        elem.value = {
          raw: this.input.slice(this.start, this.end),
          cooked: this.value
        };
        this.next();
        elem.tail = this.type === tt.backQuote;
        return this.finishNode(elem, "TemplateElement");
      };

      pp.parseTemplate = function () {
        var node = this.startNode();
        this.next();
        node.expressions = [];
        var curElt = this.parseTemplateElement();
        node.quasis = [curElt];
        while (!curElt.tail) {
          this.expect(tt.dollarBraceL);
          node.expressions.push(this.parseExpression());
          this.expect(tt.braceR);
          node.quasis.push(curElt = this.parseTemplateElement());
        }
        this.next();
        return this.finishNode(node, "TemplateLiteral");
      };

// Parse an object literal or binding pattern.

      pp.parseObj = function (isPattern, refShorthandDefaultPos) {
        var node = this.startNode(),
          first = true,
          propHash = {};
        node.properties = [];
        this.next();
        while (!this.eat(tt.braceR)) {
          if (!first) {
            this.expect(tt.comma);
            if (this.afterTrailingComma(tt.braceR)) break;
          } else first = false;

          var prop = this.startNode(),
            isGenerator = undefined,
            start = undefined;
          if (this.options.ecmaVersion >= 6) {
            prop.method = false;
            prop.shorthand = false;
            if (isPattern || refShorthandDefaultPos) start = this.markPosition();
            if (!isPattern) isGenerator = this.eat(tt.star);
          }
          this.parsePropertyName(prop);
          if (this.eat(tt.colon)) {
            prop.value = isPattern ? this.parseMaybeDefault() : this.parseMaybeAssign(false, refShorthandDefaultPos);
            prop.kind = "init";
          } else if (this.options.ecmaVersion >= 6 && this.type === tt.parenL) {
            if (isPattern) this.unexpected();
            prop.kind = "init";
            prop.method = true;
            prop.value = this.parseMethod(isGenerator);
          } else if (this.options.ecmaVersion >= 5 && !prop.computed && prop.key.type === "Identifier" && (prop.key.name === "get" || prop.key.name === "set") && (this.type != tt.comma && this.type != tt.braceR)) {
            if (isGenerator || isPattern) this.unexpected();
            prop.kind = prop.key.name;
            this.parsePropertyName(prop);
            prop.value = this.parseMethod(false);
          } else if (this.options.ecmaVersion >= 6 && !prop.computed && prop.key.type === "Identifier") {
            prop.kind = "init";
            if (isPattern) {
              if (this.isKeyword(prop.key.name) || this.strict && (reservedWords.strictBind(prop.key.name) || reservedWords.strict(prop.key.name)) || !this.options.allowReserved && this.isReservedWord(prop.key.name)) this.raise(prop.key.start, "Binding " + prop.key.name);
              prop.value = this.parseMaybeDefault(start, prop.key);
            } else if (this.type === tt.eq && refShorthandDefaultPos) {
              if (!refShorthandDefaultPos.start) refShorthandDefaultPos.start = this.start;
              prop.value = this.parseMaybeDefault(start, prop.key);
            } else {
              prop.value = prop.key;
            }
            prop.shorthand = true;
          } else this.unexpected();

          this.checkPropClash(prop, propHash);
          node.properties.push(this.finishNode(prop, "Property"));
        }
        return this.finishNode(node, isPattern ? "ObjectPattern" : "ObjectExpression");
      };

      pp.parsePropertyName = function (prop) {
        if (this.options.ecmaVersion >= 6) {
          if (this.eat(tt.bracketL)) {
            prop.computed = true;
            prop.key = this.parseMaybeAssign();
            this.expect(tt.bracketR);
            return;
          } else {
            prop.computed = false;
          }
        }
        prop.key = this.type === tt.num || this.type === tt.string ? this.parseExprAtom() : this.parseIdent(true);
      };

// Initialize empty function node.

      pp.initFunction = function (node) {
        node.id = null;
        if (this.options.ecmaVersion >= 6) {
          node.generator = false;
          node.expression = false;
        }
      };

// Parse object or class method.

      pp.parseMethod = function (isGenerator) {
        var node = this.startNode();
        this.initFunction(node);
        this.expect(tt.parenL);
        node.params = this.parseBindingList(tt.parenR, false, false);
        var allowExpressionBody = undefined;
        if (this.options.ecmaVersion >= 6) {
          node.generator = isGenerator;
          allowExpressionBody = true;
        } else {
          allowExpressionBody = false;
        }
        this.parseFunctionBody(node, allowExpressionBody);
        return this.finishNode(node, "FunctionExpression");
      };

// Parse arrow function expression with given parameters.

      pp.parseArrowExpression = function (node, params) {
        this.initFunction(node);
        node.params = this.toAssignableList(params, true);
        this.parseFunctionBody(node, true);
        return this.finishNode(node, "ArrowFunctionExpression");
      };

// Parse function body and check parameters.

      pp.parseFunctionBody = function (node, allowExpression) {
        var isExpression = allowExpression && this.type !== tt.braceL;

        if (isExpression) {
          node.body = this.parseMaybeAssign();
          node.expression = true;
        } else {
          // Start a new scope with regard to labels and the `inFunction`
          // flag (restore them to their old value afterwards).
          var oldInFunc = this.inFunction,
            oldInGen = this.inGenerator,
            oldLabels = this.labels;
          this.inFunction = true;
          this.inGenerator = node.generator;
          this.labels = [];
          node.body = this.parseBlock(true);
          node.expression = false;
          this.inFunction = oldInFunc;
          this.inGenerator = oldInGen;
          this.labels = oldLabels;
        }

        // If this is a strict mode function, verify that argument names
        // are not repeated, and it does not try to bind the words `eval`
        // or `arguments`.
        if (this.strict || !isExpression && node.body.body.length && this.isUseStrict(node.body.body[0])) {
          var nameHash = {},
            oldStrict = this.strict;
          this.strict = true;
          if (node.id) this.checkLVal(node.id, true);
          for (var i = 0; i < node.params.length; i++) {
            this.checkLVal(node.params[i], true, nameHash);
          }
          this.strict = oldStrict;
        }
      };

// Parses a comma-separated list of expressions, and returns them as
// an array. `close` is the token type that ends the list, and
// `allowEmpty` can be turned on to allow subsequent commas with
// nothing in between them to be parsed as `null` (which is needed
// for array literals).

      pp.parseExprList = function (close, allowTrailingComma, allowEmpty, refShorthandDefaultPos) {
        var elts = [],
          first = true;
        while (!this.eat(close)) {
          if (!first) {
            this.expect(tt.comma);
            if (allowTrailingComma && this.afterTrailingComma(close)) break;
          } else first = false;

          if (allowEmpty && this.type === tt.comma) {
            elts.push(null);
          } else {
            if (this.type === tt.ellipsis) elts.push(this.parseSpread(refShorthandDefaultPos)); else elts.push(this.parseMaybeAssign(false, refShorthandDefaultPos));
          }
        }
        return elts;
      };

// Parse the next token as an identifier. If `liberal` is true (used
// when parsing properties), it will also convert keywords into
// identifiers.

      pp.parseIdent = function (liberal) {
        var node = this.startNode();
        if (liberal && this.options.allowReserved == "never") liberal = false;
        if (this.type === tt.name) {
          if (!liberal && (!this.options.allowReserved && this.isReservedWord(this.value) || this.strict && reservedWords.strict(this.value) && (this.options.ecmaVersion >= 6 || this.input.slice(this.start, this.end).indexOf("\\") == -1))) this.raise(this.start, "The keyword '" + this.value + "' is reserved");
          node.name = this.value;
        } else if (liberal && this.type.keyword) {
          node.name = this.type.keyword;
        } else {
          this.unexpected();
        }
        this.next();
        return this.finishNode(node, "Identifier");
      };

// Parses yield expression inside generator.

      pp.parseYield = function () {
        var node = this.startNode();
        this.next();
        if (this.type == tt.semi || this.canInsertSemicolon() || this.type != tt.star && !this.type.startsExpr) {
          node.delegate = false;
          node.argument = null;
        } else {
          node.delegate = this.eat(tt.star);
          node.argument = this.parseMaybeAssign();
        }
        return this.finishNode(node, "YieldExpression");
      };

// Parses array and generator comprehensions.

      pp.parseComprehension = function (node, isGenerator) {
        node.blocks = [];
        while (this.type === tt._for) {
          var block = this.startNode();
          this.next();
          this.expect(tt.parenL);
          block.left = this.parseBindingAtom();
          this.checkLVal(block.left, true);
          this.expectContextual("of");
          block.right = this.parseExpression();
          this.expect(tt.parenR);
          node.blocks.push(this.finishNode(block, "ComprehensionBlock"));
        }
        node.filter = this.eat(tt._if) ? this.parseParenExpression() : null;
        node.body = this.parseExpression();
        this.expect(isGenerator ? tt.parenR : tt.bracketR);
        node.generator = isGenerator;
        return this.finishNode(node, "ComprehensionExpression");
      };

    }, {"./identifier": 3, "./state": 9, "./tokentype": 13, "./util": 14}], 3: [function (require, module, exports) {


// Test whether a given character code starts an identifier.

      "use strict";

      exports.isIdentifierStart = isIdentifierStart;

// Test whether a given character is part of an identifier.

      exports.isIdentifierChar = isIdentifierChar;
      Object.defineProperty(exports, "__esModule", {
        value: true
      });
// This is a trick taken from Esprima. It turns out that, on
// non-Chrome browsers, to check whether a string is in a set, a
// predicate containing a big ugly `switch` statement is faster than
// a regular expression, and on Chrome the two are about on par.
// This function uses `eval` (non-lexical) to produce such a
// predicate from a space-separated string of words.
//
// It starts by sorting the words by length.

      function makePredicate(words) {
        words = words.split(" ");
        var f = "",
          cats = [];
        out: for (var i = 0; i < words.length; ++i) {
          for (var j = 0; j < cats.length; ++j) {
            if (cats[j][0].length == words[i].length) {
              cats[j].push(words[i]);
              continue out;
            }
          }
          cats.push([words[i]]);
        }

        function compareTo(arr) {
          if (arr.length == 1) {
            return f += "return str === " + JSON.stringify(arr[0]) + ";";
          }
          f += "switch(str){";
          for (var i = 0; i < arr.length; ++i) {
            f += "case " + JSON.stringify(arr[i]) + ":";
          }
          f += "return true}return false;";
        }

        // When there are more than three length categories, an outer
        // switch first dispatches on the lengths, to save on comparisons.

        if (cats.length > 3) {
          cats.sort(function (a, b) {
            return b.length - a.length;
          });
          f += "switch(str.length){";
          for (var i = 0; i < cats.length; ++i) {
            var cat = cats[i];
            f += "case " + cat[0].length + ":";
            compareTo(cat);
          }
          f += "}"

          // Otherwise, simply generate a flat `switch` statement.

          ;
        } else {
          compareTo(words);
        }
        return new Function("str", f);
      }

// Reserved word lists for various dialects of the language

      var reservedWords = {
        3: makePredicate("abstract boolean byte char class double enum export extends final float goto implements import int interface long native package private protected public short static super synchronized throws transient volatile"),
        5: makePredicate("class enum extends super const export import"),
        6: makePredicate("enum await"),
        strict: makePredicate("implements interface let package private protected public static yield"),
        strictBind: makePredicate("eval arguments")
      };

      exports.reservedWords = reservedWords;
// And the keywords

      var ecma5AndLessKeywords = "break case catch continue debugger default do else finally for function if return switch throw try var while with null true false instanceof typeof void delete new in this";

      var keywords = {
        5: makePredicate(ecma5AndLessKeywords),
        6: makePredicate(ecma5AndLessKeywords + " let const class extends export import yield super")
      };

      exports.keywords = keywords;
// ## Character categories

// Big ugly regular expressions that match characters in the
// whitespace, identifier, and identifier-start categories. These
// are only applied when a character is found to actually have a
// code point above 128.
// Generated by `tools/generate-identifier-regex.js`.

      var nonASCIIidentifierStartChars = "ªµºÀ-ÖØ-öø-ˁˆ-ˑˠ-ˤˬˮͰ-ʹͶͷͺ-ͽͿΆΈ-ΊΌΎ-ΡΣ-ϵϷ-ҁҊ-ԯԱ-Ֆՙա-ևא-תװ-ײؠ-يٮٯٱ-ۓەۥۦۮۯۺ-ۼۿܐܒ-ܯݍ-ޥޱߊ-ߪߴߵߺࠀ-ࠕࠚࠤࠨࡀ-ࡘࢠ-ࢲऄ-हऽॐक़-ॡॱ-ঀঅ-ঌএঐও-নপ-রলশ-হঽৎড়ঢ়য়-ৡৰৱਅ-ਊਏਐਓ-ਨਪ-ਰਲਲ਼ਵਸ਼ਸਹਖ਼-ੜਫ਼ੲ-ੴઅ-ઍએ-ઑઓ-નપ-રલળવ-હઽૐૠૡଅ-ଌଏଐଓ-ନପ-ରଲଳଵ-ହଽଡ଼ଢ଼ୟ-ୡୱஃஅ-ஊஎ-ஐஒ-கஙசஜஞடணதந-பம-ஹௐఅ-ఌఎ-ఐఒ-నప-హఽౘౙౠౡಅ-ಌಎ-ಐಒ-ನಪ-ಳವ-ಹಽೞೠೡೱೲഅ-ഌഎ-ഐഒ-ഺഽൎൠൡൺ-ൿඅ-ඖක-නඳ-රලව-ෆก-ะาำเ-ๆກຂຄງຈຊຍດ-ທນ-ຟມ-ຣລວສຫອ-ະາຳຽເ-ໄໆໜ-ໟༀཀ-ཇཉ-ཬྈ-ྌက-ဪဿၐ-ၕၚ-ၝၡၥၦၮ-ၰၵ-ႁႎႠ-ჅჇჍა-ჺჼ-ቈቊ-ቍቐ-ቖቘቚ-ቝበ-ኈኊ-ኍነ-ኰኲ-ኵኸ-ኾዀዂ-ዅወ-ዖዘ-ጐጒ-ጕጘ-ፚᎀ-ᎏᎠ-Ᏼᐁ-ᙬᙯ-ᙿᚁ-ᚚᚠ-ᛪᛮ-ᛸᜀ-ᜌᜎ-ᜑᜠ-ᜱᝀ-ᝑᝠ-ᝬᝮ-ᝰក-ឳៗៜᠠ-ᡷᢀ-ᢨᢪᢰ-ᣵᤀ-ᤞᥐ-ᥭᥰ-ᥴᦀ-ᦫᧁ-ᧇᨀ-ᨖᨠ-ᩔᪧᬅ-ᬳᭅ-ᭋᮃ-ᮠᮮᮯᮺ-ᯥᰀ-ᰣᱍ-ᱏᱚ-ᱽᳩ-ᳬᳮ-ᳱᳵᳶᴀ-ᶿḀ-ἕἘ-Ἕἠ-ὅὈ-Ὅὐ-ὗὙὛὝὟ-ώᾀ-ᾴᾶ-ᾼιῂ-ῄῆ-ῌῐ-ΐῖ-Ίῠ-Ῥῲ-ῴῶ-ῼⁱⁿₐ-ₜℂℇℊ-ℓℕ℘-ℝℤΩℨK-ℹℼ-ℿⅅ-ⅉⅎⅠ-ↈⰀ-Ⱞⰰ-ⱞⱠ-ⳤⳫ-ⳮⳲⳳⴀ-ⴥⴧⴭⴰ-ⵧⵯⶀ-ⶖⶠ-ⶦⶨ-ⶮⶰ-ⶶⶸ-ⶾⷀ-ⷆⷈ-ⷎⷐ-ⷖⷘ-ⷞ々-〇〡-〩〱-〵〸-〼ぁ-ゖ゛-ゟァ-ヺー-ヿㄅ-ㄭㄱ-ㆎㆠ-ㆺㇰ-ㇿ㐀-䶵一-鿌ꀀ-ꒌꓐ-ꓽꔀ-ꘌꘐ-ꘟꘪꘫꙀ-ꙮꙿ-ꚝꚠ-ꛯꜗ-ꜟꜢ-ꞈꞋ-ꞎꞐ-ꞭꞰꞱꟷ-ꠁꠃ-ꠅꠇ-ꠊꠌ-ꠢꡀ-ꡳꢂ-ꢳꣲ-ꣷꣻꤊ-ꤥꤰ-ꥆꥠ-ꥼꦄ-ꦲꧏꧠ-ꧤꧦ-ꧯꧺ-ꧾꨀ-ꨨꩀ-ꩂꩄ-ꩋꩠ-ꩶꩺꩾ-ꪯꪱꪵꪶꪹ-ꪽꫀꫂꫛ-ꫝꫠ-ꫪꫲ-ꫴꬁ-ꬆꬉ-ꬎꬑ-ꬖꬠ-ꬦꬨ-ꬮꬰ-ꭚꭜ-ꭟꭤꭥꯀ-ꯢ가-힣ힰ-ퟆퟋ-ퟻ豈-舘並-龎ﬀ-ﬆﬓ-ﬗיִײַ-ﬨשׁ-זּטּ-לּמּנּסּףּפּצּ-ﮱﯓ-ﴽﵐ-ﶏﶒ-ﷇﷰ-ﷻﹰ-ﹴﹶ-ﻼＡ-Ｚａ-ｚｦ-ﾾￂ-ￇￊ-ￏￒ-ￗￚ-ￜ";
      var nonASCIIidentifierChars = "‌‍·̀-ͯ·҃-֑҇-ׇֽֿׁׂׅׄؐ-ًؚ-٩ٰۖ-ۜ۟-۪ۤۧۨ-ۭ۰-۹ܑܰ-݊ަ-ް߀-߉߫-߳ࠖ-࠙ࠛ-ࠣࠥ-ࠧࠩ-࡙࠭-࡛ࣤ-ःऺ-़ा-ॏ॑-ॗॢॣ०-९ঁ-ঃ়া-ৄেৈো-্ৗৢৣ০-৯ਁ-ਃ਼ਾ-ੂੇੈੋ-੍ੑ੦-ੱੵઁ-ઃ઼ા-ૅે-ૉો-્ૢૣ૦-૯ଁ-ଃ଼ା-ୄେୈୋ-୍ୖୗୢୣ୦-୯ஂா-ூெ-ைொ-்ௗ௦-௯ఀ-ఃా-ౄె-ైొ-్ౕౖౢౣ౦-౯ಁ-ಃ಼ಾ-ೄೆ-ೈೊ-್ೕೖೢೣ೦-೯ഁ-ഃാ-ൄെ-ൈൊ-്ൗൢൣ൦-൯ංඃ්ා-ුූෘ-ෟ෦-෯ෲෳัิ-ฺ็-๎๐-๙ັິ-ູົຼ່-ໍ໐-໙༘༙༠-༩༹༵༷༾༿ཱ-྄྆྇ྍ-ྗྙ-ྼ࿆ါ-ှ၀-၉ၖ-ၙၞ-ၠၢ-ၤၧ-ၭၱ-ၴႂ-ႍႏ-ႝ፝-፟፩-፱ᜒ-᜔ᜲ-᜴ᝒᝓᝲᝳ឴-៓៝០-៩᠋-᠍᠐-᠙ᢩᤠ-ᤫᤰ-᤻᥆-᥏ᦰ-ᧀᧈᧉ᧐-᧚ᨗ-ᨛᩕ-ᩞ᩠-᩿᩼-᪉᪐-᪙᪰-᪽ᬀ-ᬄ᬴-᭄᭐-᭙᭫-᭳ᮀ-ᮂᮡ-ᮭ᮰-᮹᯦-᯳ᰤ-᰷᱀-᱉᱐-᱙᳐-᳔᳒-᳨᳭ᳲ-᳴᳸᳹᷀-᷵᷼-᷿‿⁀⁔⃐-⃥⃜⃡-⃰⳯-⵿⳱ⷠ-〪ⷿ-゙゚〯꘠-꘩꙯ꙴ-꙽ꚟ꛰꛱ꠂ꠆ꠋꠣ-ꠧꢀꢁꢴ-꣄꣐-꣙꣠-꣱꤀-꤉ꤦ-꤭ꥇ-꥓ꦀ-ꦃ꦳-꧀꧐-꧙ꧥ꧰-꧹ꨩ-ꨶꩃꩌꩍ꩐-꩙ꩻ-ꩽꪰꪲ-ꪴꪷꪸꪾ꪿꫁ꫫ-ꫯꫵ꫶ꯣ-ꯪ꯬꯭꯰-꯹ﬞ︀-️︠-︭︳︴﹍-﹏０-９＿";

      var nonASCIIidentifierStart = new RegExp("[" + nonASCIIidentifierStartChars + "]");
      var nonASCIIidentifier = new RegExp("[" + nonASCIIidentifierStartChars + nonASCIIidentifierChars + "]");

      nonASCIIidentifierStartChars = nonASCIIidentifierChars = null;

// These are a run-length and offset encoded representation of the
// >0xffff code points that are a valid part of identifiers. The
// offset starts at 0x10000, and each pair of numbers represents an
// offset to the next range, and then a size of the range. They were
// generated by tools/generate-identifier-regex.js
      var astralIdentifierStartCodes = [0, 11, 2, 25, 2, 18, 2, 1, 2, 14, 3, 13, 35, 122, 70, 52, 268, 28, 4, 48, 48, 31, 17, 26, 6, 37, 11, 29, 3, 35, 5, 7, 2, 4, 43, 157, 99, 39, 9, 51, 157, 310, 10, 21, 11, 7, 153, 5, 3, 0, 2, 43, 2, 1, 4, 0, 3, 22, 11, 22, 10, 30, 98, 21, 11, 25, 71, 55, 7, 1, 65, 0, 16, 3, 2, 2, 2, 26, 45, 28, 4, 28, 36, 7, 2, 27, 28, 53, 11, 21, 11, 18, 14, 17, 111, 72, 955, 52, 76, 44, 33, 24, 27, 35, 42, 34, 4, 0, 13, 47, 15, 3, 22, 0, 38, 17, 2, 24, 133, 46, 39, 7, 3, 1, 3, 21, 2, 6, 2, 1, 2, 4, 4, 0, 32, 4, 287, 47, 21, 1, 2, 0, 185, 46, 82, 47, 21, 0, 60, 42, 502, 63, 32, 0, 449, 56, 1288, 920, 104, 110, 2962, 1070, 13266, 568, 8, 30, 114, 29, 19, 47, 17, 3, 32, 20, 6, 18, 881, 68, 12, 0, 67, 12, 16481, 1, 3071, 106, 6, 12, 4, 8, 8, 9, 5991, 84, 2, 70, 2, 1, 3, 0, 3, 1, 3, 3, 2, 11, 2, 0, 2, 6, 2, 64, 2, 3, 3, 7, 2, 6, 2, 27, 2, 3, 2, 4, 2, 0, 4, 6, 2, 339, 3, 24, 2, 24, 2, 30, 2, 24, 2, 30, 2, 24, 2, 30, 2, 24, 2, 30, 2, 24, 2, 7, 4149, 196, 1340, 3, 2, 26, 2, 1, 2, 0, 3, 0, 2, 9, 2, 3, 2, 0, 2, 0, 7, 0, 5, 0, 2, 0, 2, 0, 2, 2, 2, 1, 2, 0, 3, 0, 2, 0, 2, 0, 2, 0, 2, 0, 2, 1, 2, 0, 3, 3, 2, 6, 2, 3, 2, 3, 2, 0, 2, 9, 2, 16, 6, 2, 2, 4, 2, 16, 4421, 42710, 42, 4148, 12, 221, 16355, 541];
      var astralIdentifierCodes = [509, 0, 227, 0, 150, 4, 294, 9, 1368, 2, 2, 1, 6, 3, 41, 2, 5, 0, 166, 1, 1306, 2, 54, 14, 32, 9, 16, 3, 46, 10, 54, 9, 7, 2, 37, 13, 2, 9, 52, 0, 13, 2, 49, 13, 16, 9, 83, 11, 168, 11, 6, 9, 8, 2, 57, 0, 2, 6, 3, 1, 3, 2, 10, 0, 11, 1, 3, 6, 4, 4, 316, 19, 13, 9, 214, 6, 3, 8, 112, 16, 16, 9, 82, 12, 9, 9, 535, 9, 20855, 9, 135, 4, 60, 6, 26, 9, 1016, 45, 17, 3, 19723, 1, 5319, 4, 4, 5, 9, 7, 3, 6, 31, 3, 149, 2, 1418, 49, 4305, 6, 792618, 239];

// This has a complexity linear to the value of the code. The
// assumption is that looking up astral identifier characters is
// rare.
      function isInAstralSet(code, set) {
        var pos = 65536;
        for (var i = 0; i < set.length; i += 2) {
          pos += set[i];
          if (pos > code) {
            return false;
          }
          pos += set[i + 1];
          if (pos >= code) {
            return true;
          }
        }
      }

      function isIdentifierStart(code, astral) {
        if (code < 65) {
          return code === 36;
        }
        if (code < 91) {
          return true;
        }
        if (code < 97) {
          return code === 95;
        }
        if (code < 123) {
          return true;
        }
        if (code <= 65535) {
          return code >= 170 && nonASCIIidentifierStart.test(String.fromCharCode(code));
        }
        if (astral === false) {
          return false;
        }
        return isInAstralSet(code, astralIdentifierStartCodes);
      }

      function isIdentifierChar(code, astral) {
        if (code < 48) {
          return code === 36;
        }
        if (code < 58) {
          return true;
        }
        if (code < 65) {
          return false;
        }
        if (code < 91) {
          return true;
        }
        if (code < 97) {
          return code === 95;
        }
        if (code < 123) {
          return true;
        }
        if (code <= 65535) {
          return code >= 170 && nonASCIIidentifier.test(String.fromCharCode(code));
        }
        if (astral === false) {
          return false;
        }
        return isInAstralSet(code, astralIdentifierStartCodes) || isInAstralSet(code, astralIdentifierCodes);
      }

    }, {}], 4: [function (require, module, exports) {
      "use strict";

      var _createClass = (function () {
        function defineProperties(target, props) {
          for (var key in props) {
            var prop = props[key];
            prop.configurable = true;
            if (prop.value) prop.writable = true;
          }
          Object.defineProperties(target, props);
        }

        return function (Constructor, protoProps, staticProps) {
          if (protoProps) defineProperties(Constructor.prototype, protoProps);
          if (staticProps) defineProperties(Constructor, staticProps);
          return Constructor;
        };
      })();

      var _classCallCheck = function (instance, Constructor) {
        if (!(instance instanceof Constructor)) {
          throw new TypeError("Cannot call a class as a function");
        }
      };

// The `getLineInfo` function is mostly useful when the
// `locations` option is off (for performance reasons) and you
// want to find the line/column position for a given character
// offset. `input` should be the code string that the offset refers
// into.

      exports.getLineInfo = getLineInfo;
      Object.defineProperty(exports, "__esModule", {
        value: true
      });

      var Parser = require("./state").Parser;

      var lineBreakG = require("./whitespace").lineBreakG;

// These are used when `options.locations` is on, for the
// `startLoc` and `endLoc` properties.

      var Position = exports.Position = (function () {
        function Position(line, col) {
          _classCallCheck(this, Position);

          this.line = line;
          this.column = col;
        }

        _createClass(Position, {
          offset: {
            value: function offset(n) {
              return new Position(this.line, this.column + n);
            }
          }
        });

        return Position;
      })();

      var SourceLocation = exports.SourceLocation = function SourceLocation(p, start, end) {
        _classCallCheck(this, SourceLocation);

        this.start = start;
        this.end = end;
        if (p.sourceFile !== null) this.source = p.sourceFile;
      };

      function getLineInfo(input, offset) {
        for (var line = 1, cur = 0; ;) {
          lineBreakG.lastIndex = cur;
          var match = lineBreakG.exec(input);
          if (match && match.index < offset) {
            ++line;
            cur = match.index + match[0].length;
          } else {
            return new Position(line, offset - cur);
          }
        }
      }

      var pp = Parser.prototype;

// This function is used to raise exceptions on parse errors. It
// takes an offset integer (into the current `input`) to indicate
// the location of the error, attaches the position to the end
// of the error message, and then raises a `SyntaxError` with that
// message.

      pp.raise = function (pos, message) {
        var loc = getLineInfo(this.input, pos);
        message += " (" + loc.line + ":" + loc.column + ")";
        var err = new SyntaxError(message);
        err.pos = pos;
        err.loc = loc;
        err.raisedAt = this.pos;
        throw err;
      };

      pp.curPosition = function () {
        return new Position(this.curLine, this.pos - this.lineStart);
      };

      pp.markPosition = function () {
        return this.options.locations ? [this.start, this.startLoc] : this.start;
      };

    }, {"./state": 9, "./whitespace": 15}], 5: [function (require, module, exports) {
      "use strict";

      var tt = require("./tokentype").types;

      var Parser = require("./state").Parser;

      var reservedWords = require("./identifier").reservedWords;

      var has = require("./util").has;

      var pp = Parser.prototype;

// Convert existing expression atom to assignable pattern
// if possible.

      pp.toAssignable = function (node, isBinding) {
        if (this.options.ecmaVersion >= 6 && node) {
          switch (node.type) {
            case "Identifier":
            case "ObjectPattern":
            case "ArrayPattern":
            case "AssignmentPattern":
              break;

            case "ObjectExpression":
              node.type = "ObjectPattern";
              for (var i = 0; i < node.properties.length; i++) {
                var prop = node.properties[i];
                if (prop.kind !== "init") this.raise(prop.key.start, "Object pattern can't contain getter or setter");
                this.toAssignable(prop.value, isBinding);
              }
              break;

            case "ArrayExpression":
              node.type = "ArrayPattern";
              this.toAssignableList(node.elements, isBinding);
              break;

            case "AssignmentExpression":
              if (node.operator === "=") {
                node.type = "AssignmentPattern";
              } else {
                this.raise(node.left.end, "Only '=' operator can be used for specifying default value.");
              }
              break;

            case "MemberExpression":
              if (!isBinding) break;

            default:
              this.raise(node.start, "Assigning to rvalue");
          }
        }
        return node;
      };

// Convert list of expression atoms to binding list.

      pp.toAssignableList = function (exprList, isBinding) {
        var end = exprList.length;
        if (end) {
          var last = exprList[end - 1];
          if (last && last.type == "RestElement") {
            --end;
          } else if (last && last.type == "SpreadElement") {
            last.type = "RestElement";
            var arg = last.argument;
            this.toAssignable(arg, isBinding);
            if (arg.type !== "Identifier" && arg.type !== "MemberExpression" && arg.type !== "ArrayPattern") this.unexpected(arg.start);
            --end;
          }
        }
        for (var i = 0; i < end; i++) {
          var elt = exprList[i];
          if (elt) this.toAssignable(elt, isBinding);
        }
        return exprList;
      };

// Parses spread element.

      pp.parseSpread = function (refShorthandDefaultPos) {
        var node = this.startNode();
        this.next();
        node.argument = this.parseMaybeAssign(refShorthandDefaultPos);
        return this.finishNode(node, "SpreadElement");
      };

      pp.parseRest = function () {
        var node = this.startNode();
        this.next();
        node.argument = this.type === tt.name || this.type === tt.bracketL ? this.parseBindingAtom() : this.unexpected();
        return this.finishNode(node, "RestElement");
      };

// Parses lvalue (assignable) atom.

      pp.parseBindingAtom = function () {
        if (this.options.ecmaVersion < 6) return this.parseIdent();
        switch (this.type) {
          case tt.name:
            return this.parseIdent();

          case tt.bracketL:
            var node = this.startNode();
            this.next();
            node.elements = this.parseBindingList(tt.bracketR, true, true);
            return this.finishNode(node, "ArrayPattern");

          case tt.braceL:
            return this.parseObj(true);

          default:
            this.unexpected();
        }
      };

      pp.parseBindingList = function (close, allowEmpty, allowTrailingComma) {
        var elts = [],
          first = true;
        while (!this.eat(close)) {
          if (first) first = false; else this.expect(tt.comma);
          if (allowEmpty && this.type === tt.comma) {
            elts.push(null);
          } else if (allowTrailingComma && this.afterTrailingComma(close)) {
            break;
          } else if (this.type === tt.ellipsis) {
            elts.push(this.parseRest());
            this.expect(close);
            break;
          } else {
            elts.push(this.parseMaybeDefault());
          }
        }
        return elts;
      };

// Parses assignment pattern around given atom if possible.

      pp.parseMaybeDefault = function (startPos, left) {
        startPos = startPos || this.markPosition();
        left = left || this.parseBindingAtom();
        if (!this.eat(tt.eq)) return left;
        var node = this.startNodeAt(startPos);
        node.operator = "=";
        node.left = left;
        node.right = this.parseMaybeAssign();
        return this.finishNode(node, "AssignmentPattern");
      };

// Verify that a node is an lval — something that can be assigned
// to.

      pp.checkLVal = function (expr, isBinding, checkClashes) {
        switch (expr.type) {
          case "Identifier":
            if (this.strict && (reservedWords.strictBind(expr.name) || reservedWords.strict(expr.name))) this.raise(expr.start, (isBinding ? "Binding " : "Assigning to ") + expr.name + " in strict mode");
            if (checkClashes) {
              if (has(checkClashes, expr.name)) this.raise(expr.start, "Argument name clash in strict mode");
              checkClashes[expr.name] = true;
            }
            break;

          case "MemberExpression":
            if (isBinding) this.raise(expr.start, (isBinding ? "Binding" : "Assigning to") + " member expression");
            break;

          case "ObjectPattern":
            for (var i = 0; i < expr.properties.length; i++) {
              this.checkLVal(expr.properties[i].value, isBinding, checkClashes);
            }
            break;

          case "ArrayPattern":
            for (var i = 0; i < expr.elements.length; i++) {
              var elem = expr.elements[i];
              if (elem) this.checkLVal(elem, isBinding, checkClashes);
            }
            break;

          case "AssignmentPattern":
            this.checkLVal(expr.left, isBinding, checkClashes);
            break;

          case "RestElement":
            this.checkLVal(expr.argument, isBinding, checkClashes);
            break;

          default:
            this.raise(expr.start, (isBinding ? "Binding" : "Assigning to") + " rvalue");
        }
      };

    }, {"./identifier": 3, "./state": 9, "./tokentype": 13, "./util": 14}], 6: [function (require, module, exports) {
      "use strict";

      var _classCallCheck = function (instance, Constructor) {
        if (!(instance instanceof Constructor)) {
          throw new TypeError("Cannot call a class as a function");
        }
      };

      Object.defineProperty(exports, "__esModule", {
        value: true
      });

      var Parser = require("./state").Parser;

      var SourceLocation = require("./location").SourceLocation;

// Start an AST node, attaching a start offset.

      var pp = Parser.prototype;

      var Node = exports.Node = function Node() {
        _classCallCheck(this, Node);
      };

      pp.startNode = function () {
        var node = new Node();
        node.start = this.start;
        if (this.options.locations) node.loc = new SourceLocation(this, this.startLoc);
        if (this.options.directSourceFile) node.sourceFile = this.options.directSourceFile;
        if (this.options.ranges) node.range = [this.start, 0];
        return node;
      };

      pp.startNodeAt = function (pos) {
        var node = new Node(),
          start = pos;
        if (this.options.locations) {
          node.loc = new SourceLocation(this, start[1]);
          start = pos[0];
        }
        node.start = start;
        if (this.options.directSourceFile) node.sourceFile = this.options.directSourceFile;
        if (this.options.ranges) node.range = [start, 0];
        return node;
      };

// Finish an AST node, adding `type` and `end` properties.

      pp.finishNode = function (node, type) {
        node.type = type;
        node.end = this.lastTokEnd;
        if (this.options.locations) node.loc.end = this.lastTokEndLoc;
        if (this.options.ranges) node.range[1] = this.lastTokEnd;
        return node;
      };

// Finish node at given position

      pp.finishNodeAt = function (node, type, pos) {
        if (this.options.locations) {
          node.loc.end = pos[1];
          pos = pos[0];
        }
        node.type = type;
        node.end = pos;
        if (this.options.ranges) node.range[1] = pos;
        return node;
      };

    }, {"./location": 4, "./state": 9}], 7: [function (require, module, exports) {


// Interpret and default an options object

      "use strict";

      exports.getOptions = getOptions;
      Object.defineProperty(exports, "__esModule", {
        value: true
      });

      var _util = require("./util");

      var has = _util.has;
      var isArray = _util.isArray;

      var SourceLocation = require("./location").SourceLocation;

// A second optional argument can be given to further configure
// the parser process. These options are recognized:

      var defaultOptions = {
        // `ecmaVersion` indicates the ECMAScript version to parse. Must
        // be either 3, or 5, or 6. This influences support for strict
        // mode, the set of reserved words, support for getters and
        // setters and other features.
        ecmaVersion: 5,
        // Source type ("script" or "module") for different semantics
        sourceType: "script",
        // `onInsertedSemicolon` can be a callback that will be called
        // when a semicolon is automatically inserted. It will be passed
        // th position of the comma as an offset, and if `locations` is
        // enabled, it is given the location as a `{line, column}` object
        // as second argument.
        onInsertedSemicolon: null,
        // `onTrailingComma` is similar to `onInsertedSemicolon`, but for
        // trailing commas.
        onTrailingComma: null,
        // By default, reserved words are not enforced. Disable
        // `allowReserved` to enforce them. When this option has the
        // value "never", reserved words and keywords can also not be
        // used as property names.
        allowReserved: true,
        // When enabled, a return at the top level is not considered an
        // error.
        allowReturnOutsideFunction: false,
        // When enabled, import/export statements are not constrained to
        // appearing at the top of the program.
        allowImportExportEverywhere: false,
        // When enabled, hashbang directive in the beginning of file
        // is allowed and treated as a line comment.
        allowHashBang: false,
        // When `locations` is on, `loc` properties holding objects with
        // `start` and `end` properties in `{line, column}` form (with
        // line being 1-based and column 0-based) will be attached to the
        // nodes.
        locations: false,
        // A function can be passed as `onToken` option, which will
        // cause Acorn to call that function with object in the same
        // format as tokenize() returns. Note that you are not
        // allowed to call the parser from the callback—that will
        // corrupt its internal state.
        onToken: null,
        // A function can be passed as `onComment` option, which will
        // cause Acorn to call that function with `(block, text, start,
        // end)` parameters whenever a comment is skipped. `block` is a
        // boolean indicating whether this is a block (`/* */`) comment,
        // `text` is the content of the comment, and `start` and `end` are
        // character offsets that denote the start and end of the comment.
        // When the `locations` option is on, two more parameters are
        // passed, the full `{line, column}` locations of the start and
        // end of the comments. Note that you are not allowed to call the
        // parser from the callback—that will corrupt its internal state.
        onComment: null,
        // Nodes have their start and end characters offsets recorded in
        // `start` and `end` properties (directly on the node, rather than
        // the `loc` object, which holds line/column data. To also add a
        // [semi-standardized][range] `range` property holding a `[start,
        // end]` array with the same numbers, set the `ranges` option to
        // `true`.
        //
        // [range]: https://bugzilla.mozilla.org/show_bug.cgi?id=745678
        ranges: false,
        // It is possible to parse multiple files into a single AST by
        // passing the tree produced by parsing the first file as
        // `program` option in subsequent parses. This will add the
        // toplevel forms of the parsed file to the `Program` (top) node
        // of an existing parse tree.
        program: null,
        // When `locations` is on, you can pass this to record the source
        // file in every node's `loc` object.
        sourceFile: null,
        // This value, if given, is stored in every node, whether
        // `locations` is on or off.
        directSourceFile: null,
        // When enabled, parenthesized expressions are represented by
        // (non-standard) ParenthesizedExpression nodes
        preserveParens: false,
        plugins: {}
      };
      exports.defaultOptions = defaultOptions;

      function getOptions(opts) {
        var options = {};
        for (var opt in defaultOptions) {
          options[opt] = opts && has(opts, opt) ? opts[opt] : defaultOptions[opt];
        }
        if (isArray(options.onToken)) {
          (function () {
            var tokens = options.onToken;
            options.onToken = function (token) {
              return tokens.push(token);
            };
          })();
        }
        if (isArray(options.onComment)) options.onComment = pushComment(options, options.onComment);

        return options;
      }

      function pushComment(options, array) {
        return function (block, text, start, end, startLoc, endLoc) {
          var comment = {
            type: block ? "Block" : "Line",
            value: text,
            start: start,
            end: end
          };
          if (options.locations) comment.loc = new SourceLocation(this, startLoc, endLoc);
          if (options.ranges) comment.range = [start, end];
          array.push(comment);
        };
      }

    }, {"./location": 4, "./util": 14}], 8: [function (require, module, exports) {
      "use strict";

      var tt = require("./tokentype").types;

      var Parser = require("./state").Parser;

      var lineBreak = require("./whitespace").lineBreak;

      var pp = Parser.prototype;

// ## Parser utilities

// Test whether a statement node is the string literal `"use strict"`.

      pp.isUseStrict = function (stmt) {
        return this.options.ecmaVersion >= 5 && stmt.type === "ExpressionStatement" && stmt.expression.type === "Literal" && stmt.expression.value === "use strict";
      };

// Predicate that tests whether the next token is of the given
// type, and if yes, consumes it as a side effect.

      pp.eat = function (type) {
        if (this.type === type) {
          this.next();
          return true;
        } else {
          return false;
        }
      };

// Tests whether parsed token is a contextual keyword.

      pp.isContextual = function (name) {
        return this.type === tt.name && this.value === name;
      };

// Consumes contextual keyword if possible.

      pp.eatContextual = function (name) {
        return this.value === name && this.eat(tt.name);
      };

// Asserts that following token is given contextual keyword.

      pp.expectContextual = function (name) {
        if (!this.eatContextual(name)) this.unexpected();
      };

// Test whether a semicolon can be inserted at the current position.

      pp.canInsertSemicolon = function () {
        return this.type === tt.eof || this.type === tt.braceR || lineBreak.test(this.input.slice(this.lastTokEnd, this.start));
      };

      pp.insertSemicolon = function () {
        if (this.canInsertSemicolon()) {
          if (this.options.onInsertedSemicolon) this.options.onInsertedSemicolon(this.lastTokEnd, this.lastTokEndLoc);
          return true;
        }
      };

// Consume a semicolon, or, failing that, see if we are allowed to
// pretend that there is a semicolon at this position.

      pp.semicolon = function () {
        if (!this.eat(tt.semi) && !this.insertSemicolon()) this.unexpected();
      };

      pp.afterTrailingComma = function (tokType) {
        if (this.type == tokType) {
          if (this.options.onTrailingComma) this.options.onTrailingComma(this.lastTokStart, this.lastTokStartLoc);
          this.next();
          return true;
        }
      };

// Expect a token of a given type. If found, consume it, otherwise,
// raise an unexpected token error.

      pp.expect = function (type) {
        this.eat(type) || this.unexpected();
      };

// Raise an unexpected token error.

      pp.unexpected = function (pos) {
        this.raise(pos != null ? pos : this.start, "Unexpected token");
      };

    }, {"./state": 9, "./tokentype": 13, "./whitespace": 15}], 9: [function (require, module, exports) {
      "use strict";

      exports.Parser = Parser;
      Object.defineProperty(exports, "__esModule", {
        value: true
      });

      var _identifier = require("./identifier");

      var reservedWords = _identifier.reservedWords;
      var keywords = _identifier.keywords;

      var _tokentype = require("./tokentype");

      var tt = _tokentype.types;
      var lineBreak = _tokentype.lineBreak;

      function Parser(options, input, startPos) {
        this.options = options;
        this.loadPlugins(this.options.plugins);
        this.sourceFile = this.options.sourceFile || null;
        this.isKeyword = keywords[this.options.ecmaVersion >= 6 ? 6 : 5];
        this.isReservedWord = reservedWords[this.options.ecmaVersion];
        this.input = input;

        // Set up token state

        // The current position of the tokenizer in the input.
        if (startPos) {
          this.pos = startPos;
          this.lineStart = Math.max(0, this.input.lastIndexOf("\n", startPos));
          this.curLine = this.input.slice(0, this.lineStart).split(lineBreak).length;
        } else {
          this.pos = this.lineStart = 0;
          this.curLine = 1;
        }

        // Properties of the current token:
        // Its type
        this.type = tt.eof;
        // For tokens that include more information than their type, the value
        this.value = null;
        // Its start and end offset
        this.start = this.end = this.pos;
        // And, if locations are used, the {line, column} object
        // corresponding to those offsets
        this.startLoc = this.endLoc = null;

        // Position information for the previous token
        this.lastTokEndLoc = this.lastTokStartLoc = null;
        this.lastTokStart = this.lastTokEnd = this.pos;

        // The context stack is used to superficially track syntactic
        // context to predict whether a regular expression is allowed in a
        // given position.
        this.context = this.initialContext();
        this.exprAllowed = true;

        // Figure out if it's a module code.
        this.strict = this.inModule = this.options.sourceType === "module";

        // Flags to track whether we are in a function, a generator.
        this.inFunction = this.inGenerator = false;
        // Labels in scope.
        this.labels = [];

        // If enabled, skip leading hashbang line.
        if (this.pos === 0 && this.options.allowHashBang && this.input.slice(0, 2) === "#!") this.skipLineComment(2);
      }

      Parser.prototype.extend = function (name, f) {
        this[name] = f(this[name]);
      };

// Registered plugins

      var plugins = {};

      exports.plugins = plugins;
      Parser.prototype.loadPlugins = function (plugins) {
        for (var _name in plugins) {
          var plugin = exports.plugins[_name];
          if (!plugin) throw new Error("Plugin '" + _name + "' not found");
          plugin(this, plugins[_name]);
        }
      };

    }, {"./identifier": 3, "./tokentype": 13}], 10: [function (require, module, exports) {
      "use strict";

      var tt = require("./tokentype").types;

      var Parser = require("./state").Parser;

      var lineBreak = require("./whitespace").lineBreak;

      var pp = Parser.prototype;

// ### Statement parsing

// Parse a program. Initializes the parser, reads any number of
// statements, and wraps them in a Program node.  Optionally takes a
// `program` argument.  If present, the statements will be appended
// to its body instead of creating a new node.

      pp.parseTopLevel = function (node) {
        var first = true;
        if (!node.body) node.body = [];
        while (this.type !== tt.eof) {
          var stmt = this.parseStatement(true, true);
          node.body.push(stmt);
          if (first && this.isUseStrict(stmt)) this.setStrict(true);
          first = false;
        }
        this.next();
        if (this.options.ecmaVersion >= 6) {
          node.sourceType = this.options.sourceType;
        }
        return this.finishNode(node, "Program");
      };

      var loopLabel = {kind: "loop"},
        switchLabel = {kind: "switch"};

// Parse a single statement.
//
// If expecting a statement and finding a slash operator, parse a
// regular expression literal. This is to handle cases like
// `if (foo) /blah/.exec(foo)`, where looking at the previous token
// does not help.

      pp.parseStatement = function (declaration, topLevel) {
        var starttype = this.type,
          node = this.startNode();

        // Most types of statements are recognized by the keyword they
        // start with. Many are trivial to parse, some require a bit of
        // complexity.

        switch (starttype) {
          case tt._break:
          case tt._continue:
            return this.parseBreakContinueStatement(node, starttype.keyword);
          case tt._debugger:
            return this.parseDebuggerStatement(node);
          case tt._do:
            return this.parseDoStatement(node);
          case tt._for:
            return this.parseForStatement(node);
          case tt._function:
            if (!declaration && this.options.ecmaVersion >= 6) this.unexpected();
            return this.parseFunctionStatement(node);
          case tt._class:
            if (!declaration) this.unexpected();
            return this.parseClass(node, true);
          case tt._if:
            return this.parseIfStatement(node);
          case tt._return:
            return this.parseReturnStatement(node);
          case tt._switch:
            return this.parseSwitchStatement(node);
          case tt._throw:
            return this.parseThrowStatement(node);
          case tt._try:
            return this.parseTryStatement(node);
          case tt._let:
          case tt._const:
            if (!declaration) this.unexpected(); // NOTE: falls through to _var
          case tt._var:
            return this.parseVarStatement(node, starttype);
          case tt._while:
            return this.parseWhileStatement(node);
          case tt._with:
            return this.parseWithStatement(node);
          case tt.braceL:
            return this.parseBlock();
          case tt.semi:
            return this.parseEmptyStatement(node);
          case tt._export:
          case tt._import:
            if (!this.options.allowImportExportEverywhere) {
              if (!topLevel) this.raise(this.start, "'import' and 'export' may only appear at the top level");
              if (!this.inModule) this.raise(this.start, "'import' and 'export' may appear only with 'sourceType: module'");
            }
            return starttype === tt._import ? this.parseImport(node) : this.parseExport(node);

          // If the statement does not start with a statement keyword or a
          // brace, it's an ExpressionStatement or LabeledStatement. We
          // simply start parsing an expression, and afterwards, if the
          // next token is a colon and the expression was a simple
          // Identifier node, we switch to interpreting it as a label.
          default:
            var maybeName = this.value,
              expr = this.parseExpression();
            if (starttype === tt.name && expr.type === "Identifier" && this.eat(tt.colon)) return this.parseLabeledStatement(node, maybeName, expr); else return this.parseExpressionStatement(node, expr);
        }
      };

      pp.parseBreakContinueStatement = function (node, keyword) {
        var isBreak = keyword == "break";
        this.next();
        if (this.eat(tt.semi) || this.insertSemicolon()) node.label = null; else if (this.type !== tt.name) this.unexpected(); else {
          node.label = this.parseIdent();
          this.semicolon();
        }

        // Verify that there is an actual destination to break or
        // continue to.
        for (var i = 0; i < this.labels.length; ++i) {
          var lab = this.labels[i];
          if (node.label == null || lab.name === node.label.name) {
            if (lab.kind != null && (isBreak || lab.kind === "loop")) break;
            if (node.label && isBreak) break;
          }
        }
        if (i === this.labels.length) this.raise(node.start, "Unsyntactic " + keyword);
        return this.finishNode(node, isBreak ? "BreakStatement" : "ContinueStatement");
      };

      pp.parseDebuggerStatement = function (node) {
        this.next();
        this.semicolon();
        return this.finishNode(node, "DebuggerStatement");
      };

      pp.parseDoStatement = function (node) {
        this.next();
        this.labels.push(loopLabel);
        node.body = this.parseStatement(false);
        this.labels.pop();
        this.expect(tt._while);
        node.test = this.parseParenExpression();
        if (this.options.ecmaVersion >= 6) this.eat(tt.semi); else this.semicolon();
        return this.finishNode(node, "DoWhileStatement");
      };

// Disambiguating between a `for` and a `for`/`in` or `for`/`of`
// loop is non-trivial. Basically, we have to parse the init `var`
// statement or expression, disallowing the `in` operator (see
// the second parameter to `parseExpression`), and then check
// whether the next token is `in` or `of`. When there is no init
// part (semicolon immediately after the opening parenthesis), it
// is a regular `for` loop.

      pp.parseForStatement = function (node) {
        this.next();
        this.labels.push(loopLabel);
        this.expect(tt.parenL);
        if (this.type === tt.semi) return this.parseFor(node, null);
        if (this.type === tt._var || this.type === tt._let || this.type === tt._const) {
          var _init = this.startNode(),
            varKind = this.type;
          this.next();
          this.parseVar(_init, true, varKind);
          this.finishNode(_init, "VariableDeclaration");
          if ((this.type === tt._in || this.options.ecmaVersion >= 6 && this.isContextual("of")) && _init.declarations.length === 1 && !(varKind !== tt._var && _init.declarations[0].init)) return this.parseForIn(node, _init);
          return this.parseFor(node, _init);
        }
        var refShorthandDefaultPos = {start: 0};
        var init = this.parseExpression(true, refShorthandDefaultPos);
        if (this.type === tt._in || this.options.ecmaVersion >= 6 && this.isContextual("of")) {
          this.toAssignable(init);
          this.checkLVal(init);
          return this.parseForIn(node, init);
        } else if (refShorthandDefaultPos.start) {
          this.unexpected(refShorthandDefaultPos.start);
        }
        return this.parseFor(node, init);
      };

      pp.parseFunctionStatement = function (node) {
        this.next();
        return this.parseFunction(node, true);
      };

      pp.parseIfStatement = function (node) {
        this.next();
        node.test = this.parseParenExpression();
        node.consequent = this.parseStatement(false);
        node.alternate = this.eat(tt._else) ? this.parseStatement(false) : null;
        return this.finishNode(node, "IfStatement");
      };

      pp.parseReturnStatement = function (node) {
        if (!this.inFunction && !this.options.allowReturnOutsideFunction) this.raise(this.start, "'return' outside of function");
        this.next();

        // In `return` (and `break`/`continue`), the keywords with
        // optional arguments, we eagerly look for a semicolon or the
        // possibility to insert one.

        if (this.eat(tt.semi) || this.insertSemicolon()) node.argument = null; else {
          node.argument = this.parseExpression();
          this.semicolon();
        }
        return this.finishNode(node, "ReturnStatement");
      };

      pp.parseSwitchStatement = function (node) {
        this.next();
        node.discriminant = this.parseParenExpression();
        node.cases = [];
        this.expect(tt.braceL);
        this.labels.push(switchLabel);

        // Statements under must be grouped (by label) in SwitchCase
        // nodes. `cur` is used to keep the node that we are currently
        // adding statements to.

        for (var cur, sawDefault; this.type != tt.braceR;) {
          if (this.type === tt._case || this.type === tt._default) {
            var isCase = this.type === tt._case;
            if (cur) this.finishNode(cur, "SwitchCase");
            node.cases.push(cur = this.startNode());
            cur.consequent = [];
            this.next();
            if (isCase) {
              cur.test = this.parseExpression();
            } else {
              if (sawDefault) this.raise(this.lastTokStart, "Multiple default clauses");
              sawDefault = true;
              cur.test = null;
            }
            this.expect(tt.colon);
          } else {
            if (!cur) this.unexpected();
            cur.consequent.push(this.parseStatement(true));
          }
        }
        if (cur) this.finishNode(cur, "SwitchCase");
        this.next(); // Closing brace
        this.labels.pop();
        return this.finishNode(node, "SwitchStatement");
      };

      pp.parseThrowStatement = function (node) {
        this.next();
        if (lineBreak.test(this.input.slice(this.lastTokEnd, this.start))) this.raise(this.lastTokEnd, "Illegal newline after throw");
        node.argument = this.parseExpression();
        this.semicolon();
        return this.finishNode(node, "ThrowStatement");
      };

// Reused empty array added for node fields that are always empty.

      var empty = [];

      pp.parseTryStatement = function (node) {
        this.next();
        node.block = this.parseBlock();
        node.handler = null;
        if (this.type === tt._catch) {
          var clause = this.startNode();
          this.next();
          this.expect(tt.parenL);
          clause.param = this.parseBindingAtom();
          this.checkLVal(clause.param, true);
          this.expect(tt.parenR);
          clause.guard = null;
          clause.body = this.parseBlock();
          node.handler = this.finishNode(clause, "CatchClause");
        }
        node.guardedHandlers = empty;
        node.finalizer = this.eat(tt._finally) ? this.parseBlock() : null;
        if (!node.handler && !node.finalizer) this.raise(node.start, "Missing catch or finally clause");
        return this.finishNode(node, "TryStatement");
      };

      pp.parseVarStatement = function (node, kind) {
        this.next();
        this.parseVar(node, false, kind);
        this.semicolon();
        return this.finishNode(node, "VariableDeclaration");
      };

      pp.parseWhileStatement = function (node) {
        this.next();
        node.test = this.parseParenExpression();
        this.labels.push(loopLabel);
        node.body = this.parseStatement(false);
        this.labels.pop();
        return this.finishNode(node, "WhileStatement");
      };

      pp.parseWithStatement = function (node) {
        if (this.strict) this.raise(this.start, "'with' in strict mode");
        this.next();
        node.object = this.parseParenExpression();
        node.body = this.parseStatement(false);
        return this.finishNode(node, "WithStatement");
      };

      pp.parseEmptyStatement = function (node) {
        this.next();
        return this.finishNode(node, "EmptyStatement");
      };

      pp.parseLabeledStatement = function (node, maybeName, expr) {
        for (var i = 0; i < this.labels.length; ++i) {
          if (this.labels[i].name === maybeName) this.raise(expr.start, "Label '" + maybeName + "' is already declared");
        }
        var kind = this.type.isLoop ? "loop" : this.type === tt._switch ? "switch" : null;
        this.labels.push({name: maybeName, kind: kind});
        node.body = this.parseStatement(true);
        this.labels.pop();
        node.label = expr;
        return this.finishNode(node, "LabeledStatement");
      };

      pp.parseExpressionStatement = function (node, expr) {
        node.expression = expr;
        this.semicolon();
        return this.finishNode(node, "ExpressionStatement");
      };

// Parse a semicolon-enclosed block of statements, handling `"use
// strict"` declarations when `allowStrict` is true (used for
// function bodies).

      pp.parseBlock = function (allowStrict) {
        var node = this.startNode(),
          first = true,
          oldStrict = undefined;
        node.body = [];
        this.expect(tt.braceL);
        while (!this.eat(tt.braceR)) {
          var stmt = this.parseStatement(true);
          node.body.push(stmt);
          if (first && allowStrict && this.isUseStrict(stmt)) {
            oldStrict = this.strict;
            this.setStrict(this.strict = true);
          }
          first = false;
        }
        if (oldStrict === false) this.setStrict(false);
        return this.finishNode(node, "BlockStatement");
      };

// Parse a regular `for` loop. The disambiguation code in
// `parseStatement` will already have parsed the init statement or
// expression.

      pp.parseFor = function (node, init) {
        node.init = init;
        this.expect(tt.semi);
        node.test = this.type === tt.semi ? null : this.parseExpression();
        this.expect(tt.semi);
        node.update = this.type === tt.parenR ? null : this.parseExpression();
        this.expect(tt.parenR);
        node.body = this.parseStatement(false);
        this.labels.pop();
        return this.finishNode(node, "ForStatement");
      };

// Parse a `for`/`in` and `for`/`of` loop, which are almost
// same from parser's perspective.

      pp.parseForIn = function (node, init) {
        var type = this.type === tt._in ? "ForInStatement" : "ForOfStatement";
        this.next();
        node.left = init;
        node.right = this.parseExpression();
        this.expect(tt.parenR);
        node.body = this.parseStatement(false);
        this.labels.pop();
        return this.finishNode(node, type);
      };

// Parse a list of variable declarations.

      pp.parseVar = function (node, isFor, kind) {
        node.declarations = [];
        node.kind = kind.keyword;
        for (; ;) {
          var decl = this.startNode();
          decl.id = this.parseBindingAtom();
          this.checkLVal(decl.id, true);
          if (this.eat(tt.eq)) {
            decl.init = this.parseMaybeAssign(isFor);
          } else if (kind === tt._const && !(this.type === tt._in || this.options.ecmaVersion >= 6 && this.isContextual("of"))) {
            this.unexpected();
          } else if (decl.id.type != "Identifier" && !(isFor && (this.type === tt._in || this.isContextual("of")))) {
            this.raise(this.lastTokEnd, "Complex binding patterns require an initialization value");
          } else {
            decl.init = null;
          }
          node.declarations.push(this.finishNode(decl, "VariableDeclarator"));
          if (!this.eat(tt.comma)) break;
        }
        return node;
      };

// Parse a function declaration or literal (depending on the
// `isStatement` parameter).

      pp.parseFunction = function (node, isStatement, allowExpressionBody) {
        this.initFunction(node);
        if (this.options.ecmaVersion >= 6) node.generator = this.eat(tt.star);
        if (isStatement || this.type === tt.name) node.id = this.parseIdent();
        this.expect(tt.parenL);
        node.params = this.parseBindingList(tt.parenR, false, false);
        this.parseFunctionBody(node, allowExpressionBody);
        return this.finishNode(node, isStatement ? "FunctionDeclaration" : "FunctionExpression");
      };

// Parse a class declaration or literal (depending on the
// `isStatement` parameter).

      pp.parseClass = function (node, isStatement) {
        this.next();
        node.id = this.type === tt.name ? this.parseIdent() : isStatement ? this.unexpected() : null;
        node.superClass = this.eat(tt._extends) ? this.parseExprSubscripts() : null;
        var classBody = this.startNode();
        classBody.body = [];
        this.expect(tt.braceL);
        while (!this.eat(tt.braceR)) {
          if (this.eat(tt.semi)) continue;
          var method = this.startNode();
          var isGenerator = this.eat(tt.star);
          this.parsePropertyName(method);
          if (this.type !== tt.parenL && !method.computed && method.key.type === "Identifier" && method.key.name === "static") {
            if (isGenerator) this.unexpected();
            method["static"] = true;
            isGenerator = this.eat(tt.star);
            this.parsePropertyName(method);
          } else {
            method["static"] = false;
          }
          method.kind = "method";
          if (!method.computed && !isGenerator) {
            if (method.key.type === "Identifier") {
              if (this.type !== tt.parenL && (method.key.name === "get" || method.key.name === "set")) {
                method.kind = method.key.name;
                this.parsePropertyName(method);
              } else if (!method["static"] && method.key.name === "constructor") {
                method.kind = "constructor";
              }
            } else if (!method["static"] && method.key.type === "Literal" && method.key.value === "constructor") {
              method.kind = "constructor";
            }
          }
          method.value = this.parseMethod(isGenerator);
          classBody.body.push(this.finishNode(method, "MethodDefinition"));
        }
        node.body = this.finishNode(classBody, "ClassBody");
        return this.finishNode(node, isStatement ? "ClassDeclaration" : "ClassExpression");
      };

// Parses module export declaration.

      pp.parseExport = function (node) {
        this.next();
        // export * from '...'
        if (this.eat(tt.star)) {
          this.expectContextual("from");
          node.source = this.type === tt.string ? this.parseExprAtom() : this.unexpected();
          this.semicolon();
          return this.finishNode(node, "ExportAllDeclaration");
        }
        if (this.eat(tt._default)) {
          // export default ...
          var expr = this.parseMaybeAssign();
          var needsSemi = true;
          if (expr.type == "FunctionExpression" || expr.type == "ClassExpression") {
            needsSemi = false;
            if (expr.id) {
              expr.type = expr.type == "FunctionExpression" ? "FunctionDeclaration" : "ClassDeclaration";
            }
          }
          node.declaration = expr;
          if (needsSemi) this.semicolon();
          return this.finishNode(node, "ExportDefaultDeclaration");
        }
        // export var|const|let|function|class ...
        if (this.type.keyword) {
          node.declaration = this.parseStatement(true);
          node.specifiers = [];
          node.source = null;
        } else {
          // export { x, y as z } [from '...']
          node.declaration = null;
          node.specifiers = this.parseExportSpecifiers();
          if (this.eatContextual("from")) {
            node.source = this.type === tt.string ? this.parseExprAtom() : this.unexpected();
          } else {
            node.source = null;
          }
          this.semicolon();
        }
        return this.finishNode(node, "ExportNamedDeclaration");
      };

// Parses a comma-separated list of module exports.

      pp.parseExportSpecifiers = function () {
        var nodes = [],
          first = true;
        // export { x, y as z } [from '...']
        this.expect(tt.braceL);
        while (!this.eat(tt.braceR)) {
          if (!first) {
            this.expect(tt.comma);
            if (this.afterTrailingComma(tt.braceR)) break;
          } else first = false;

          var node = this.startNode();
          node.local = this.parseIdent(this.type === tt._default);
          node.exported = this.eatContextual("as") ? this.parseIdent(true) : node.local;
          nodes.push(this.finishNode(node, "ExportSpecifier"));
        }
        return nodes;
      };

// Parses import declaration.

      pp.parseImport = function (node) {
        this.next();
        // import '...'
        if (this.type === tt.string) {
          node.specifiers = empty;
          node.source = this.parseExprAtom();
          node.kind = "";
        } else {
          node.specifiers = this.parseImportSpecifiers();
          this.expectContextual("from");
          node.source = this.type === tt.string ? this.parseExprAtom() : this.unexpected();
        }
        this.semicolon();
        return this.finishNode(node, "ImportDeclaration");
      };

// Parses a comma-separated list of module imports.

      pp.parseImportSpecifiers = function () {
        var nodes = [],
          first = true;
        if (this.type === tt.name) {
          // import defaultObj, { x, y as z } from '...'
          var node = this.startNode();
          node.local = this.parseIdent();
          this.checkLVal(node.local, true);
          nodes.push(this.finishNode(node, "ImportDefaultSpecifier"));
          if (!this.eat(tt.comma)) return nodes;
        }
        if (this.type === tt.star) {
          var node = this.startNode();
          this.next();
          this.expectContextual("as");
          node.local = this.parseIdent();
          this.checkLVal(node.local, true);
          nodes.push(this.finishNode(node, "ImportNamespaceSpecifier"));
          return nodes;
        }
        this.expect(tt.braceL);
        while (!this.eat(tt.braceR)) {
          if (!first) {
            this.expect(tt.comma);
            if (this.afterTrailingComma(tt.braceR)) break;
          } else first = false;

          var node = this.startNode();
          node.imported = this.parseIdent(true);
          node.local = this.eatContextual("as") ? this.parseIdent() : node.imported;
          this.checkLVal(node.local, true);
          nodes.push(this.finishNode(node, "ImportSpecifier"));
        }
        return nodes;
      };

    }, {"./state": 9, "./tokentype": 13, "./whitespace": 15}], 11: [function (require, module, exports) {
      "use strict";

      var _classCallCheck = function (instance, Constructor) {
        if (!(instance instanceof Constructor)) {
          throw new TypeError("Cannot call a class as a function");
        }
      };

      Object.defineProperty(exports, "__esModule", {
        value: true
      });
// The algorithm used to determine whether a regexp can appear at a
// given point in the program is loosely based on sweet.js' approach.
// See https://github.com/mozilla/sweet.js/wiki/design

      var Parser = require("./state").Parser;

      var tt = require("./tokentype").types;

      var lineBreak = require("./whitespace").lineBreak;

      var TokContext = exports.TokContext = function TokContext(token, isExpr, preserveSpace, override) {
        _classCallCheck(this, TokContext);

        this.token = token;
        this.isExpr = isExpr;
        this.preserveSpace = preserveSpace;
        this.override = override;
      };

      var types = {
        b_stat: new TokContext("{", false),
        b_expr: new TokContext("{", true),
        b_tmpl: new TokContext("${", true),
        p_stat: new TokContext("(", false),
        p_expr: new TokContext("(", true),
        q_tmpl: new TokContext("`", true, true, function (p) {
          return p.readTmplToken();
        }),
        f_expr: new TokContext("function", true)
      };

      exports.types = types;
      var pp = Parser.prototype;

      pp.initialContext = function () {
        return [types.b_stat];
      };

      pp.braceIsBlock = function (prevType) {
        var parent = undefined;
        if (prevType === tt.colon && (parent = this.curContext()).token == "{") return !parent.isExpr;
        if (prevType === tt._return) return lineBreak.test(this.input.slice(this.lastTokEnd, this.start));
        if (prevType === tt._else || prevType === tt.semi || prevType === tt.eof) return true;
        if (prevType == tt.braceL) return this.curContext() === types.b_stat;
        return !this.exprAllowed;
      };

      pp.updateContext = function (prevType) {
        var update = undefined,
          type = this.type;
        if (type.keyword && prevType == tt.dot) this.exprAllowed = false; else if (update = type.updateContext) update.call(this, prevType); else this.exprAllowed = type.beforeExpr;
      };

// Token-specific context update code

      tt.parenR.updateContext = tt.braceR.updateContext = function () {
        if (this.context.length == 1) {
          this.exprAllowed = true;
          return;
        }
        var out = this.context.pop();
        if (out === types.b_stat && this.curContext() === types.f_expr) {
          this.context.pop();
          this.exprAllowed = false;
        } else if (out === types.b_tmpl) {
          this.exprAllowed = true;
        } else {
          this.exprAllowed = !out.isExpr;
        }
      };

      tt.braceL.updateContext = function (prevType) {
        this.context.push(this.braceIsBlock(prevType) ? types.b_stat : types.b_expr);
        this.exprAllowed = true;
      };

      tt.dollarBraceL.updateContext = function () {
        this.context.push(types.b_tmpl);
        this.exprAllowed = true;
      };

      tt.parenL.updateContext = function (prevType) {
        var statementParens = prevType === tt._if || prevType === tt._for || prevType === tt._with || prevType === tt._while;
        this.context.push(statementParens ? types.p_stat : types.p_expr);
        this.exprAllowed = true;
      };

      tt.incDec.updateContext = function () {
      };

      tt._function.updateContext = function () {
        if (this.curContext() !== types.b_stat) this.context.push(types.f_expr);
        this.exprAllowed = false;
      };

      tt.backQuote.updateContext = function () {
        if (this.curContext() === types.q_tmpl) this.context.pop(); else this.context.push(types.q_tmpl);
        this.exprAllowed = false;
      };

// tokExprAllowed stays unchanged

    }, {"./state": 9, "./tokentype": 13, "./whitespace": 15}], 12: [function (require, module, exports) {
      "use strict";

      var _classCallCheck = function (instance, Constructor) {
        if (!(instance instanceof Constructor)) {
          throw new TypeError("Cannot call a class as a function");
        }
      };

      Object.defineProperty(exports, "__esModule", {
        value: true
      });

      var _identifier = require("./identifier");

      var isIdentifierStart = _identifier.isIdentifierStart;
      var isIdentifierChar = _identifier.isIdentifierChar;

      var _tokentype = require("./tokentype");

      var tt = _tokentype.types;
      var keywordTypes = _tokentype.keywords;

      var Parser = require("./state").Parser;

      var SourceLocation = require("./location").SourceLocation;

      var _whitespace = require("./whitespace");

      var lineBreak = _whitespace.lineBreak;
      var lineBreakG = _whitespace.lineBreakG;
      var isNewLine = _whitespace.isNewLine;
      var nonASCIIwhitespace = _whitespace.nonASCIIwhitespace;

// Object type used to represent tokens. Note that normally, tokens
// simply exist as properties on the parser object. This is only
// used for the onToken callback and the external tokenizer.

      var Token = exports.Token = function Token(p) {
        _classCallCheck(this, Token);

        this.type = p.type;
        this.value = p.value;
        this.start = p.start;
        this.end = p.end;
        if (p.options.locations) this.loc = new SourceLocation(p, p.startLoc, p.endLoc);
        if (p.options.ranges) this.range = [p.start, p.end];
      };

// ## Tokenizer

      var pp = Parser.prototype;

// Move to the next token

      pp.next = function () {
        if (this.options.onToken) this.options.onToken(new Token(this));

        this.lastTokEnd = this.end;
        this.lastTokStart = this.start;
        this.lastTokEndLoc = this.endLoc;
        this.lastTokStartLoc = this.startLoc;
        this.nextToken();
      };

      pp.getToken = function () {
        this.next();
        return new Token(this);
      };

// If we're in an ES6 environment, make parsers iterable
      if (typeof Symbol !== "undefined") pp[Symbol.iterator] = function () {
        var self = this;
        return {
          next: function next() {
            var token = self.getToken();
            return {
              done: token.type === tt.eof,
              value: token
            };
          }
        };
      };

// Toggle strict mode. Re-reads the next number or string to please
// pedantic tests (`"use strict"; 010;` should fail).

      pp.setStrict = function (strict) {
        this.strict = strict;
        if (this.type !== tt.num && this.type !== tt.string) return;
        this.pos = this.start;
        if (this.options.locations) {
          while (this.pos < this.lineStart) {
            this.lineStart = this.input.lastIndexOf("\n", this.lineStart - 2) + 1;
            --this.curLine;
          }
        }
        this.nextToken();
      };

      pp.curContext = function () {
        return this.context[this.context.length - 1];
      };

// Read a single token, updating the parser object's token-related
// properties.

      pp.nextToken = function () {
        var curContext = this.curContext();
        if (!curContext || !curContext.preserveSpace) this.skipSpace();

        this.start = this.pos;
        if (this.options.locations) this.startLoc = this.curPosition();
        if (this.pos >= this.input.length) return this.finishToken(tt.eof);

        if (curContext.override) return curContext.override(this); else this.readToken(this.fullCharCodeAtPos());
      };

      pp.readToken = function (code) {
        // Identifier or keyword. '\uXXXX' sequences are allowed in
        // identifiers, so '\' also dispatches to that.
        if (isIdentifierStart(code, this.options.ecmaVersion >= 6) || code === 92 /* '\' */) return this.readWord();

        return this.getTokenFromCode(code);
      };

      pp.fullCharCodeAtPos = function () {
        var code = this.input.charCodeAt(this.pos);
        if (code <= 55295 || code >= 57344) return code;
        var next = this.input.charCodeAt(this.pos + 1);
        return (code << 10) + next - 56613888;
      };

      pp.skipBlockComment = function () {
        var startLoc = this.options.onComment && this.options.locations && this.curPosition();
        var start = this.pos,
          end = this.input.indexOf("*/", this.pos += 2);
        if (end === -1) this.raise(this.pos - 2, "Unterminated comment");
        this.pos = end + 2;
        if (this.options.locations) {
          lineBreakG.lastIndex = start;
          var match = undefined;
          while ((match = lineBreakG.exec(this.input)) && match.index < this.pos) {
            ++this.curLine;
            this.lineStart = match.index + match[0].length;
          }
        }
        if (this.options.onComment) this.options.onComment(true, this.input.slice(start + 2, end), start, this.pos, startLoc, this.options.locations && this.curPosition());
      };

      pp.skipLineComment = function (startSkip) {
        var start = this.pos;
        var startLoc = this.options.onComment && this.options.locations && this.curPosition();
        var ch = this.input.charCodeAt(this.pos += startSkip);
        while (this.pos < this.input.length && ch !== 10 && ch !== 13 && ch !== 8232 && ch !== 8233) {
          ++this.pos;
          ch = this.input.charCodeAt(this.pos);
        }
        if (this.options.onComment) this.options.onComment(false, this.input.slice(start + startSkip, this.pos), start, this.pos, startLoc, this.options.locations && this.curPosition());
      };

// Called at the start of the parse and after every token. Skips
// whitespace and comments, and.

      pp.skipSpace = function () {
        while (this.pos < this.input.length) {
          var ch = this.input.charCodeAt(this.pos);
          if (ch === 32) {
            // ' '
            ++this.pos;
          } else if (ch === 13) {
            ++this.pos;
            var next = this.input.charCodeAt(this.pos);
            if (next === 10) {
              ++this.pos;
            }
            if (this.options.locations) {
              ++this.curLine;
              this.lineStart = this.pos;
            }
          } else if (ch === 10 || ch === 8232 || ch === 8233) {
            ++this.pos;
            if (this.options.locations) {
              ++this.curLine;
              this.lineStart = this.pos;
            }
          } else if (ch > 8 && ch < 14) {
            ++this.pos;
          } else if (ch === 47) {
            // '/'
            var next = this.input.charCodeAt(this.pos + 1);
            if (next === 42) {
              // '*'
              this.skipBlockComment();
            } else if (next === 47) {
              // '/'
              this.skipLineComment(2);
            } else break;
          } else if (ch === 160) {
            // '\xa0'
            ++this.pos;
          } else if (ch >= 5760 && nonASCIIwhitespace.test(String.fromCharCode(ch))) {
            ++this.pos;
          } else {
            break;
          }
        }
      };

// Called at the end of every token. Sets `end`, `val`, and
// maintains `context` and `exprAllowed`, and skips the space after
// the token, so that the next one's `start` will point at the
// right position.

      pp.finishToken = function (type, val) {
        this.end = this.pos;
        if (this.options.locations) this.endLoc = this.curPosition();
        var prevType = this.type;
        this.type = type;
        this.value = val;

        this.updateContext(prevType);
      };

// ### Token reading

// This is the function that is called to fetch the next token. It
// is somewhat obscure, because it works in character codes rather
// than characters, and because operator parsing has been inlined
// into it.
//
// All in the name of speed.
//
      pp.readToken_dot = function () {
        var next = this.input.charCodeAt(this.pos + 1);
        if (next >= 48 && next <= 57) return this.readNumber(true);
        var next2 = this.input.charCodeAt(this.pos + 2);
        if (this.options.ecmaVersion >= 6 && next === 46 && next2 === 46) {
          // 46 = dot '.'
          this.pos += 3;
          return this.finishToken(tt.ellipsis);
        } else {
          ++this.pos;
          return this.finishToken(tt.dot);
        }
      };

      pp.readToken_slash = function () {
        // '/'
        var next = this.input.charCodeAt(this.pos + 1);
        if (this.exprAllowed) {
          ++this.pos;
          return this.readRegexp();
        }
        if (next === 61) return this.finishOp(tt.assign, 2);
        return this.finishOp(tt.slash, 1);
      };

      pp.readToken_mult_modulo = function (code) {
        // '%*'
        var next = this.input.charCodeAt(this.pos + 1);
        if (next === 61) return this.finishOp(tt.assign, 2);
        return this.finishOp(code === 42 ? tt.star : tt.modulo, 1);
      };

      pp.readToken_pipe_amp = function (code) {
        // '|&'
        var next = this.input.charCodeAt(this.pos + 1);
        if (next === code) return this.finishOp(code === 124 ? tt.logicalOR : tt.logicalAND, 2);
        if (next === 61) return this.finishOp(tt.assign, 2);
        return this.finishOp(code === 124 ? tt.bitwiseOR : tt.bitwiseAND, 1);
      };

      pp.readToken_caret = function () {
        // '^'
        var next = this.input.charCodeAt(this.pos + 1);
        if (next === 61) return this.finishOp(tt.assign, 2);
        return this.finishOp(tt.bitwiseXOR, 1);
      };

      pp.readToken_plus_min = function (code) {
        // '+-'
        var next = this.input.charCodeAt(this.pos + 1);
        if (next === code) {
          if (next == 45 && this.input.charCodeAt(this.pos + 2) == 62 && lineBreak.test(this.input.slice(this.lastTokEnd, this.pos))) {
            // A `-->` line comment
            this.skipLineComment(3);
            this.skipSpace();
            return this.nextToken();
          }
          return this.finishOp(tt.incDec, 2);
        }
        if (next === 61) return this.finishOp(tt.assign, 2);
        return this.finishOp(tt.plusMin, 1);
      };

      pp.readToken_lt_gt = function (code) {
        // '<>'
        var next = this.input.charCodeAt(this.pos + 1);
        var size = 1;
        if (next === code) {
          size = code === 62 && this.input.charCodeAt(this.pos + 2) === 62 ? 3 : 2;
          if (this.input.charCodeAt(this.pos + size) === 61) return this.finishOp(tt.assign, size + 1);
          return this.finishOp(tt.bitShift, size);
        }
        if (next == 33 && code == 60 && this.input.charCodeAt(this.pos + 2) == 45 && this.input.charCodeAt(this.pos + 3) == 45) {
          if (this.inModule) unexpected();
          // `<!--`, an XML-style comment that should be interpreted as a line comment
          this.skipLineComment(4);
          this.skipSpace();
          return this.nextToken();
        }
        if (next === 61) size = this.input.charCodeAt(this.pos + 2) === 61 ? 3 : 2;
        return this.finishOp(tt.relational, size);
      };

      pp.readToken_eq_excl = function (code) {
        // '=!'
        var next = this.input.charCodeAt(this.pos + 1);
        if (next === 61) return this.finishOp(tt.equality, this.input.charCodeAt(this.pos + 2) === 61 ? 3 : 2);
        if (code === 61 && next === 62 && this.options.ecmaVersion >= 6) {
          // '=>'
          this.pos += 2;
          return this.finishToken(tt.arrow);
        }
        return this.finishOp(code === 61 ? tt.eq : tt.prefix, 1);
      };

      pp.getTokenFromCode = function (code) {
        switch (code) {
          // The interpretation of a dot depends on whether it is followed
          // by a digit or another two dots.
          case 46:
            // '.'
            return this.readToken_dot();

          // Punctuation tokens.
          case 40:
            ++this.pos;
            return this.finishToken(tt.parenL);
          case 41:
            ++this.pos;
            return this.finishToken(tt.parenR);
          case 59:
            ++this.pos;
            return this.finishToken(tt.semi);
          case 44:
            ++this.pos;
            return this.finishToken(tt.comma);
          case 91:
            ++this.pos;
            return this.finishToken(tt.bracketL);
          case 93:
            ++this.pos;
            return this.finishToken(tt.bracketR);
          case 123:
            ++this.pos;
            return this.finishToken(tt.braceL);
          case 125:
            ++this.pos;
            return this.finishToken(tt.braceR);
          case 58:
            ++this.pos;
            return this.finishToken(tt.colon);
          case 63:
            ++this.pos;
            return this.finishToken(tt.question);

          case 96:
            // '`'
            if (this.options.ecmaVersion < 6) break;
            ++this.pos;
            return this.finishToken(tt.backQuote);

          case 48:
            // '0'
            var next = this.input.charCodeAt(this.pos + 1);
            if (next === 120 || next === 88) return this.readRadixNumber(16); // '0x', '0X' - hex number
            if (this.options.ecmaVersion >= 6) {
              if (next === 111 || next === 79) return this.readRadixNumber(8); // '0o', '0O' - octal number
              if (next === 98 || next === 66) return this.readRadixNumber(2); // '0b', '0B' - binary number
            }
          // Anything else beginning with a digit is an integer, octal
          // number, or float.
          case 49:
          case 50:
          case 51:
          case 52:
          case 53:
          case 54:
          case 55:
          case 56:
          case 57:
            // 1-9
            return this.readNumber(false);

          // Quotes produce strings.
          case 34:
          case 39:
            // '"', "'"
            return this.readString(code);

          // Operators are parsed inline in tiny state machines. '=' (61) is
          // often referred to. `finishOp` simply skips the amount of
          // characters it is given as second argument, and returns a token
          // of the type given by its first argument.

          case 47:
            // '/'
            return this.readToken_slash();

          case 37:
          case 42:
            // '%*'
            return this.readToken_mult_modulo(code);

          case 124:
          case 38:
            // '|&'
            return this.readToken_pipe_amp(code);

          case 94:
            // '^'
            return this.readToken_caret();

          case 43:
          case 45:
            // '+-'
            return this.readToken_plus_min(code);

          case 60:
          case 62:
            // '<>'
            return this.readToken_lt_gt(code);

          case 61:
          case 33:
            // '=!'
            return this.readToken_eq_excl(code);

          case 126:
            // '~'
            return this.finishOp(tt.prefix, 1);
        }

        this.raise(this.pos, "Unexpected character '" + codePointToString(code) + "'");
      };

      pp.finishOp = function (type, size) {
        var str = this.input.slice(this.pos, this.pos + size);
        this.pos += size;
        return this.finishToken(type, str);
      };

      var regexpUnicodeSupport = false;
      try {
        new RegExp("￿", "u");
        regexpUnicodeSupport = true;
      } catch (e) {
      }

// Parse a regular expression. Some context-awareness is necessary,
// since a '/' inside a '[]' set does not end the expression.

      pp.readRegexp = function () {
        var escaped = undefined,
          inClass = undefined,
          start = this.pos;
        for (; ;) {
          if (this.pos >= this.input.length) this.raise(start, "Unterminated regular expression");
          var ch = this.input.charAt(this.pos);
          if (lineBreak.test(ch)) this.raise(start, "Unterminated regular expression");
          if (!escaped) {
            if (ch === "[") inClass = true; else if (ch === "]" && inClass) inClass = false; else if (ch === "/" && !inClass) break;
            escaped = ch === "\\";
          } else escaped = false;
          ++this.pos;
        }
        var content = this.input.slice(start, this.pos);
        ++this.pos;
        // Need to use `readWord1` because '\uXXXX' sequences are allowed
        // here (don't ask).
        var mods = this.readWord1();
        var tmp = content;
        if (mods) {
          var validFlags = /^[gmsiy]*$/;
          if (this.options.ecmaVersion >= 6) validFlags = /^[gmsiyu]*$/;
          if (!validFlags.test(mods)) this.raise(start, "Invalid regular expression flag");
          if (mods.indexOf("u") >= 0 && !regexpUnicodeSupport) {
            // Replace each astral symbol and every Unicode escape sequence that
            // possibly represents an astral symbol or a paired surrogate with a
            // single ASCII symbol to avoid throwing on regular expressions that
            // are only valid in combination with the `/u` flag.
            // Note: replacing with the ASCII symbol `x` might cause false
            // negatives in unlikely scenarios. For example, `[\u{61}-b]` is a
            // perfectly valid pattern that is equivalent to `[a-b]`, but it would
            // be replaced by `[x-b]` which throws an error.
            tmp = tmp.replace(/\\u([a-fA-F0-9]{4})|\\u\{([0-9a-fA-F]+)\}|[\uD800-\uDBFF][\uDC00-\uDFFF]/g, "x");
          }
        }
        // Detect invalid regular expressions.
        try {
          new RegExp(tmp);
        } catch (e) {
          if (e instanceof SyntaxError) this.raise(start, "Error parsing regular expression: " + e.message);
          this.raise(e);
        }
        // Get a regular expression object for this pattern-flag pair, or `null` in
        // case the current environment doesn't support the flags it uses.
        var value = undefined;
        try {
          value = new RegExp(content, mods);
        } catch (err) {
          value = null;
        }
        return this.finishToken(tt.regexp, {pattern: content, flags: mods, value: value});
      };

// Read an integer in the given radix. Return null if zero digits
// were read, the integer value otherwise. When `len` is given, this
// will return `null` unless the integer has exactly `len` digits.

      pp.readInt = function (radix, len) {
        var start = this.pos,
          total = 0;
        for (var i = 0, e = len == null ? Infinity : len; i < e; ++i) {
          var code = this.input.charCodeAt(this.pos),
            val = undefined;
          if (code >= 97) val = code - 97 + 10; // a
          else if (code >= 65) val = code - 65 + 10; // A
          else if (code >= 48 && code <= 57) val = code - 48; // 0-9
          else val = Infinity;
          if (val >= radix) break;
          ++this.pos;
          total = total * radix + val;
        }
        if (this.pos === start || len != null && this.pos - start !== len) return null;

        return total;
      };

      pp.readRadixNumber = function (radix) {
        this.pos += 2; // 0x
        var val = this.readInt(radix);
        if (val == null) this.raise(this.start + 2, "Expected number in radix " + radix);
        if (isIdentifierStart(this.fullCharCodeAtPos())) this.raise(this.pos, "Identifier directly after number");
        return this.finishToken(tt.num, val);
      };

// Read an integer, octal integer, or floating-point number.

      pp.readNumber = function (startsWithDot) {
        var start = this.pos,
          isFloat = false,
          octal = this.input.charCodeAt(this.pos) === 48;
        if (!startsWithDot && this.readInt(10) === null) this.raise(start, "Invalid number");
        if (this.input.charCodeAt(this.pos) === 46) {
          ++this.pos;
          this.readInt(10);
          isFloat = true;
        }
        var next = this.input.charCodeAt(this.pos);
        if (next === 69 || next === 101) {
          // 'eE'
          next = this.input.charCodeAt(++this.pos);
          if (next === 43 || next === 45) ++this.pos; // '+-'
          if (this.readInt(10) === null) this.raise(start, "Invalid number");
          isFloat = true;
        }
        if (isIdentifierStart(this.fullCharCodeAtPos())) this.raise(this.pos, "Identifier directly after number");

        var str = this.input.slice(start, this.pos),
          val = undefined;
        if (isFloat) val = parseFloat(str); else if (!octal || str.length === 1) val = parseInt(str, 10); else if (/[89]/.test(str) || this.strict) this.raise(start, "Invalid number"); else val = parseInt(str, 8);
        return this.finishToken(tt.num, val);
      };

// Read a string value, interpreting backslash-escapes.

      pp.readCodePoint = function () {
        var ch = this.input.charCodeAt(this.pos),
          code = undefined;

        if (ch === 123) {
          if (this.options.ecmaVersion < 6) this.unexpected();
          ++this.pos;
          code = this.readHexChar(this.input.indexOf("}", this.pos) - this.pos);
          ++this.pos;
          if (code > 1114111) this.unexpected();
        } else {
          code = this.readHexChar(4);
        }
        return code;
      };

      function codePointToString(code) {
        // UTF-16 Decoding
        if (code <= 65535) {
          return String.fromCharCode(code);
        }
        return String.fromCharCode((code - 65536 >> 10) + 55296, (code - 65536 & 1023) + 56320);
      }

      pp.readString = function (quote) {
        var out = "",
          chunkStart = ++this.pos;
        for (; ;) {
          if (this.pos >= this.input.length) this.raise(this.start, "Unterminated string constant");
          var ch = this.input.charCodeAt(this.pos);
          if (ch === quote) break;
          if (ch === 92) {
            // '\'
            out += this.input.slice(chunkStart, this.pos);
            out += this.readEscapedChar();
            chunkStart = this.pos;
          } else {
            if (isNewLine(ch)) this.raise(this.start, "Unterminated string constant");
            ++this.pos;
          }
        }
        out += this.input.slice(chunkStart, this.pos++);
        return this.finishToken(tt.string, out);
      };

// Reads template string tokens.

      pp.readTmplToken = function () {
        var out = "",
          chunkStart = this.pos;
        for (; ;) {
          if (this.pos >= this.input.length) this.raise(this.start, "Unterminated template");
          var ch = this.input.charCodeAt(this.pos);
          if (ch === 96 || ch === 36 && this.input.charCodeAt(this.pos + 1) === 123) {
            // '`', '${'
            if (this.pos === this.start && this.type === tt.template) {
              if (ch === 36) {
                this.pos += 2;
                return this.finishToken(tt.dollarBraceL);
              } else {
                ++this.pos;
                return this.finishToken(tt.backQuote);
              }
            }
            out += this.input.slice(chunkStart, this.pos);
            return this.finishToken(tt.template, out);
          }
          if (ch === 92) {
            // '\'
            out += this.input.slice(chunkStart, this.pos);
            out += this.readEscapedChar();
            chunkStart = this.pos;
          } else if (isNewLine(ch)) {
            out += this.input.slice(chunkStart, this.pos);
            ++this.pos;
            if (ch === 13 && this.input.charCodeAt(this.pos) === 10) {
              ++this.pos;
              out += "\n";
            } else {
              out += String.fromCharCode(ch);
            }
            if (this.options.locations) {
              ++this.curLine;
              this.lineStart = this.pos;
            }
            chunkStart = this.pos;
          } else {
            ++this.pos;
          }
        }
      };

// Used to read escaped characters

      pp.readEscapedChar = function () {
        var ch = this.input.charCodeAt(++this.pos);
        var octal = /^[0-7]+/.exec(this.input.slice(this.pos, this.pos + 3));
        if (octal) octal = octal[0];
        while (octal && parseInt(octal, 8) > 255) octal = octal.slice(0, -1);
        if (octal === "0") octal = null;
        ++this.pos;
        if (octal) {
          if (this.strict) this.raise(this.pos - 2, "Octal literal in strict mode");
          this.pos += octal.length - 1;
          return String.fromCharCode(parseInt(octal, 8));
        } else {
          switch (ch) {
            case 110:
              return "\n"; // 'n' -> '\n'
            case 114:
              return "\r"; // 'r' -> '\r'
            case 120:
              return String.fromCharCode(this.readHexChar(2)); // 'x'
            case 117:
              return codePointToString(this.readCodePoint()); // 'u'
            case 116:
              return "\t"; // 't' -> '\t'
            case 98:
              return "\b"; // 'b' -> '\b'
            case 118:
              return "\u000b"; // 'v' -> '\u000b'
            case 102:
              return "\f"; // 'f' -> '\f'
            case 48:
              return "\u0000"; // 0 -> '\0'
            case 13:
              if (this.input.charCodeAt(this.pos) === 10) ++this.pos; // '\r\n'
            case 10:
              // ' \n'
              if (this.options.locations) {
                this.lineStart = this.pos;
                ++this.curLine;
              }
              return "";
            default:
              return String.fromCharCode(ch);
          }
        }
      };

// Used to read character escape sequences ('\x', '\u', '\U').

      pp.readHexChar = function (len) {
        var n = this.readInt(16, len);
        if (n === null) this.raise(this.start, "Bad character escape sequence");
        return n;
      };

// Used to signal to callers of `readWord1` whether the word
// contained any escape sequences. This is needed because words with
// escape sequences must not be interpreted as keywords.

      var containsEsc;

// Read an identifier, and return it as a string. Sets `containsEsc`
// to whether the word contained a '\u' escape.
//
// Incrementally adds only escaped chars, adding other chunks as-is
// as a micro-optimization.

      pp.readWord1 = function () {
        containsEsc = false;
        var word = "",
          first = true,
          chunkStart = this.pos;
        var astral = this.options.ecmaVersion >= 6;
        while (this.pos < this.input.length) {
          var ch = this.fullCharCodeAtPos();
          if (isIdentifierChar(ch, astral)) {
            this.pos += ch <= 65535 ? 1 : 2;
          } else if (ch === 92) {
            // "\"
            containsEsc = true;
            word += this.input.slice(chunkStart, this.pos);
            var escStart = this.pos;
            if (this.input.charCodeAt(++this.pos) != 117) // "u"
              this.raise(this.pos, "Expecting Unicode escape sequence \\uXXXX");
            ++this.pos;
            var esc = this.readCodePoint();
            if (!(first ? isIdentifierStart : isIdentifierChar)(esc, astral)) this.raise(escStart, "Invalid Unicode escape");
            word += codePointToString(esc);
            chunkStart = this.pos;
          } else {
            break;
          }
          first = false;
        }
        return word + this.input.slice(chunkStart, this.pos);
      };

// Read an identifier or keyword token. Will check for reserved
// words when necessary.

      pp.readWord = function () {
        var word = this.readWord1();
        var type = tt.name;
        if ((this.options.ecmaVersion >= 6 || !containsEsc) && this.isKeyword(word)) type = keywordTypes[word];
        return this.finishToken(type, word);
      };

    }, {"./identifier": 3, "./location": 4, "./state": 9, "./tokentype": 13, "./whitespace": 15}], 13: [function (require, module, exports) {
      "use strict";

      var _classCallCheck = function (instance, Constructor) {
        if (!(instance instanceof Constructor)) {
          throw new TypeError("Cannot call a class as a function");
        }
      };

      Object.defineProperty(exports, "__esModule", {
        value: true
      });
// ## Token types

// The assignment of fine-grained, information-carrying type objects
// allows the tokenizer to store the information it has about a
// token in a way that is very cheap for the parser to look up.

// All token type variables start with an underscore, to make them
// easy to recognize.

// The `beforeExpr` property is used to disambiguate between regular
// expressions and divisions. It is set on all token types that can
// be followed by an expression (thus, a slash after them would be a
// regular expression).
//
// `isLoop` marks a keyword as starting a loop, which is important
// to know when parsing a label, in order to allow or disallow
// continue jumps to that label.

      var TokenType = exports.TokenType = function TokenType(label) {
        var conf = arguments[1] === undefined ? {} : arguments[1];

        _classCallCheck(this, TokenType);

        this.label = label;
        this.keyword = conf.keyword;
        this.beforeExpr = !!conf.beforeExpr;
        this.startsExpr = !!conf.startsExpr;
        this.isLoop = !!conf.isLoop;
        this.isAssign = !!conf.isAssign;
        this.prefix = !!conf.prefix;
        this.postfix = !!conf.postfix;
        this.binop = conf.binop || null;
        this.updateContext = null;
      };

      function binop(name, prec) {
        return new TokenType(name, {beforeExpr: true, binop: prec});
      }

      var beforeExpr = {beforeExpr: true},
        startsExpr = {startsExpr: true};

      var types = {
        num: new TokenType("num", startsExpr),
        regexp: new TokenType("regexp", startsExpr),
        string: new TokenType("string", startsExpr),
        name: new TokenType("name", startsExpr),
        eof: new TokenType("eof"),

        // Punctuation token types.
        bracketL: new TokenType("[", {beforeExpr: true, startsExpr: true}),
        bracketR: new TokenType("]"),
        braceL: new TokenType("{", {beforeExpr: true, startsExpr: true}),
        braceR: new TokenType("}"),
        parenL: new TokenType("(", {beforeExpr: true, startsExpr: true}),
        parenR: new TokenType(")"),
        comma: new TokenType(",", beforeExpr),
        semi: new TokenType(";", beforeExpr),
        colon: new TokenType(":", beforeExpr),
        dot: new TokenType("."),
        question: new TokenType("?", beforeExpr),
        arrow: new TokenType("=>", beforeExpr),
        template: new TokenType("template"),
        ellipsis: new TokenType("...", beforeExpr),
        backQuote: new TokenType("`", startsExpr),
        dollarBraceL: new TokenType("${", {beforeExpr: true, startsExpr: true}),

        // Operators. These carry several kinds of properties to help the
        // parser use them properly (the presence of these properties is
        // what categorizes them as operators).
        //
        // `binop`, when present, specifies that this operator is a binary
        // operator, and will refer to its precedence.
        //
        // `prefix` and `postfix` mark the operator as a prefix or postfix
        // unary operator.
        //
        // `isAssign` marks all of `=`, `+=`, `-=` etcetera, which act as
        // binary operators with a very low precedence, that should result
        // in AssignmentExpression nodes.

        eq: new TokenType("=", {beforeExpr: true, isAssign: true}),
        assign: new TokenType("_=", {beforeExpr: true, isAssign: true}),
        incDec: new TokenType("++/--", {prefix: true, postfix: true, startsExpr: true}),
        prefix: new TokenType("prefix", {beforeExpr: true, prefix: true, startsExpr: true}),
        logicalOR: binop("||", 1),
        logicalAND: binop("&&", 2),
        bitwiseOR: binop("|", 3),
        bitwiseXOR: binop("^", 4),
        bitwiseAND: binop("&", 5),
        equality: binop("==/!=", 6),
        relational: binop("</>", 7),
        bitShift: binop("<</>>", 8),
        plusMin: new TokenType("+/-", {beforeExpr: true, binop: 9, prefix: true, startsExpr: true}),
        modulo: binop("%", 10),
        star: binop("*", 10),
        slash: binop("/", 10)
      };

      exports.types = types;
// Map keyword names to token types.

      var keywords = {};

      exports.keywords = keywords;

// Succinct definitions of keyword token types
      function kw(name) {
        var options = arguments[1] === undefined ? {} : arguments[1];

        options.keyword = name;
        keywords[name] = types["_" + name] = new TokenType(name, options);
      }

      kw("break");
      kw("case", beforeExpr);
      kw("catch");
      kw("continue");
      kw("debugger");
      kw("default");
      kw("do", {isLoop: true});
      kw("else", beforeExpr);
      kw("finally");
      kw("for", {isLoop: true});
      kw("function");
      kw("if");
      kw("return", beforeExpr);
      kw("switch");
      kw("throw", beforeExpr);
      kw("try");
      kw("var");
      kw("let");
      kw("const");
      kw("while", {isLoop: true});
      kw("with");
      kw("new", {beforeExpr: true, startsExpr: true});
      kw("this", startsExpr);
      kw("super", startsExpr);
      kw("class");
      kw("extends", beforeExpr);
      kw("export");
      kw("import");
      kw("yield", {beforeExpr: true, startsExpr: true});
      kw("null", startsExpr);
      kw("true", startsExpr);
      kw("false", startsExpr);
      kw("in", {beforeExpr: true, binop: 7});
      kw("instanceof", {beforeExpr: true, binop: 7});
      kw("typeof", {beforeExpr: true, prefix: true, startsExpr: true});
      kw("void", {beforeExpr: true, prefix: true, startsExpr: true});
      kw("delete", {beforeExpr: true, prefix: true, startsExpr: true});

    }, {}], 14: [function (require, module, exports) {
      "use strict";

      exports.isArray = isArray;

// Checks if an object has a property.

      exports.has = has;
      Object.defineProperty(exports, "__esModule", {
        value: true
      });

      function isArray(obj) {
        return Object.prototype.toString.call(obj) === "[object Array]";
      }

      function has(obj, propName) {
        return Object.prototype.hasOwnProperty.call(obj, propName);
      }

    }, {}], 15: [function (require, module, exports) {
      "use strict";

      exports.isNewLine = isNewLine;
      Object.defineProperty(exports, "__esModule", {
        value: true
      });
// Matches a whole line break (where CRLF is considered a single
// line break). Used to count lines.

      var lineBreak = /\r\n?|\n|\u2028|\u2029/;
      exports.lineBreak = lineBreak;
      var lineBreakG = new RegExp(lineBreak.source, "g");

      exports.lineBreakG = lineBreakG;

      function isNewLine(code) {
        return code === 10 || code === 13 || code === 8232 || code == 8233;
      }

      var nonASCIIwhitespace = /[\u1680\u180e\u2000-\u200a\u202f\u205f\u3000\ufeff]/;
      exports.nonASCIIwhitespace = nonASCIIwhitespace;

    }, {}]
  }, {}, [1])(1)
});
